package com.iris.live.services.services.impl;

import com.alibaba.fastjson.JSON;
import com.google.common.base.Strings;
import com.google.common.collect.Maps;
import com.google.gson.JsonObject;
import com.iris.live.services.common.*;
import com.iris.live.services.common.reconsitution.*;
import com.iris.live.services.data.models.*;
import com.iris.live.services.data.repositories.*;
import com.iris.live.services.models.PageData;
import com.iris.live.services.models.ResultData;
import com.iris.live.services.services.ApprovalService;
import com.iris.live.services.services.BrandService;
import com.iris.live.services.services.FinanceReceivablesService;
import com.iris.live.services.services.SetService;
import org.apache.poi.openxml4j.exceptions.NotOfficeXmlFileException;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.InputStream;
import java.math.BigDecimal;
import java.sql.Time;
import java.sql.Timestamp;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;


/**
 * @author 黄永平
 */
@Component("approvalService")
@Service
@Transactional
public class ApprovalServiceImpl implements ApprovalService {
    //虚拟车架号前缀
    private static String VIRTUAL_STOCK_PREF;
    private Logger logger = LoggerFactory.getLogger(ApprovalServiceImpl.class);
    @Autowired
    private PushApprovalWorkFlowRepository pushApprovalWorkFlowRepository;

    @Autowired
    private CancelApprovalWorkflowRepository cancelApprovalWorkflowRepository;

    @Autowired
    private ImgtRepository imgtRepository;

    @Autowired
    private 顾客记录汇总Repository 顾客记录汇总Repository;

    @Autowired
    private ApprovalRepository approvalRepository;

    @Autowired
    private 报价单表Repository repository报价单表;

    @Autowired
    private 报价订单表Repository repository报价订单表;

    @Autowired
    private 报价精品详细表Repository repository报价精品详细表;
    @Autowired
    private 报价精品详细表精品Repository repository报价精品详细精品表;

    @Autowired
    private Lsh库存表Repository lsh库存表Repository;

    @Autowired
    private Lsh库存内部可见Repository lsh库存内部可见Repository;

    @Autowired
    private Lsh车型Repository lsh车型Repository;

    @Autowired
    private 顾客记录汇总Repository repository顾客记录汇总;

    @Autowired
    private Lsh消息Repository lsh消息Repository;

    @Autowired
    private 顾客进店记录表Repository repository顾客进店记录表;

    @Autowired
    private 用户Repository repository用户;

    @Autowired
    private Itask基础设置Repository itask基础设置Repository;

    @Autowired
    private 顾客待裁决Repository repository顾客待裁决;

    @Autowired
    private VirtualStockModelRepository virtualStockModelRepository;

    @Autowired
    private 顾客订单记录Repository repository顾客订单记录;

    @Autowired
    private 报价交车表Repository repository报价交车表;

    @Resource(name="setServiceImpl")
    private SetService setService;

    @Autowired
    private CustomerInfoRepository customerInfoRepository;
    @Autowired
    private CustomReassignLogRepository customReassignLogRepository;

    @Autowired
    private PushApprovalWorkFlowRepository2 pushApprovalWorkFlowRepository2;
    @Autowired
    private SaleAdminCarResourceCheckRepository saleAdminCarResourceCheckRepository;
    @Autowired
    private PushApprovalItemSettingRepository pushApprovalItemSettingRepository;
    @Autowired
    private CarTransferLogRepository carTransferLogRepository;

    @Autowired
    private Lsh经销商表Repository lsh经销商表Repository;

    @Autowired
    private Lsh金融申请表Repository lsh金融申请表Repository;

    @Autowired
    private FinanceLogRepository financeLogRepository;

    @Autowired
    private Lsh保险申请附属Repository lsh保险申请附属Repository;

    @Autowired
    private Lsh导入名单Repository lsh导入名单Repository;

    @Autowired
    private 用户Repository 用户repository;

    @Autowired
    private CustJudgeLogRespository custJudgeLogRespository;

    @Autowired
    private MessageSettingRepository messageSettingRepository;

    @Autowired
    private SalesRepository salesRepository;

    @Autowired
    private 报价付款详细Repository repository报价付款详细;

    @Autowired
    private TDefeatLogRepository TDefeatLogRepository;

    @Autowired
    private 跟进记录表Repository repository跟进记录表;

    @Autowired
    private FinanceDepositCheckRepository financeDepositCheckRepository;

    @Resource
    private TBoutiqueCallCheckRepository tBoutiqueCallCheckRepository;

    @Resource
    private BrandService brandService;

    @Resource
    private FinanceReceivablesService financeReceivablesService;

    @Autowired
    private SnpBusinessSetLogsRepository snpBusinessSetLogsRepository;

    /**
     * 集团导入合同审批相关的车型权限数据
     *
     * @param file 前端EXCEL
     * @return 标准返回格式
     */
    @Override
    public ResultData importPrivilegeForCarModel(MultipartFile file, String user) {
        logger.info("importPrivilegeForCarModel传入参数:" + file); // 因为是EXCEL，这里不可能打印出需要的数据
        String errMsg = "importPrivilegeForCarModel车型限价数据导入异常";
        try {
            // Excel解析
            InputStream inputStream = file.getInputStream();
            XSSFWorkbook workbook;
            try {
                workbook = new XSSFWorkbook(inputStream);
            } catch (NotOfficeXmlFileException e) {
                errMsg = "导入非EXCEL文件，或者表格被另一程序打开或使用，请关闭该程序。";
                throw new Exception();
            }
            XSSFSheet sheet = workbook.getSheet("新车销售限价表");
            if (sheet == null) {
                errMsg = "未找到新车销售限价表,请确认sheet名称为新车销售限价表";
                throw new Exception();
            }
            // 数据校验
            Set<String> brands = new HashSet<>();
            brands.addAll(brandService.getBrandListByUser(user));

            List<Lsh车型Model> carMoList = lsh车型Repository.findAll();
            Map<String, Integer> keyMap = new HashMap<>();
            List<Itask基础设置Model> iTaskMoList = new ArrayList<>();
            Map<String,String> permitMap = Maps.newHashMap();
            List<SnpBusinessSetLogs> list = new ArrayList<SnpBusinessSetLogs>();
            int i = 5; // 系统数据起始行
            while (true) {
                int j = i + 1; // 表格行号
                Row row = sheet.getRow(i);
                String permit = row.getCell(0).toString() == null ? null : row.getCell(0).toString().trim(); // 许可
                String carBrand = row.getCell(1).toString() == null ? null : row.getCell(1).toString().trim(); // 品牌
                String carClass = row.getCell(2).toString() == null ? null : row.getCell(2).toString().trim(); // 车系
                String carModel = row.getCell(3).toString() == null ? null : row.getCell(3).toString().trim(); // 车型
                String carDetail = row.getCell(4).toString() == null ? null : row.getCell(4).toString().trim(); // 车款
                if (permit == null || permit.length() == 0) { // 不写或多个空格，数据无效
                    errMsg = "第" + j + "行许可无数据";
                    throw new Exception();
                }
                if (carBrand == null || carBrand.length() == 0) { // 不写或多个空格，数据无效
                    errMsg = "第" + j + "行品牌无数据";
                    throw new Exception();
                }
                if (carClass == null || carClass.length() == 0) { // 不写或多个空格，数据无效
                    errMsg = "第" + j + "行车系无数据";
                    throw new Exception();
                }
                if (carModel == null || carModel.length() == 0) { // 不写或多个空格，数据无效
                    errMsg = "第" + j + "行车型无数据";
                    throw new Exception();
                }
                if (carDetail == null || carDetail.length() == 0) { // 不写或多个空格，数据无效
                    errMsg = "第" + j + "行车款无数据";
                    throw new Exception();
                }
                permitMap.put(permit,permit);
                if("N/A".equalsIgnoreCase(carBrand)){
                    carBrand = "";
                }else {
                    carBrand = carBrand.trim();
                }

                if("N/A".equalsIgnoreCase(carClass)){
                    carClass = "";
                }else {
                    carClass = carClass.trim();
                }

                if("N/A".equalsIgnoreCase(carModel)) {
                    carModel = "";
                }else{
                    carModel = carModel.trim();
                }

                if("N/A".equalsIgnoreCase(carDetail)) {
                    carDetail = "";
                }else{
                    carDetail = carDetail.trim();
                }

                String carBrandStr = carBrand.trim();
                String carClassStr = carClass.trim();
                String carModelStr = carModel.trim();
                String carDetailStr = carDetail.trim();
                String carKey = (carBrand + "|" + carClass + "|" + carModelStr + "|" + carDetailStr).trim();
                if (keyMap.keySet().contains(carKey)) {
                    errMsg = "第" + keyMap.get(carKey) + "行车型与第" + j + "行重复，请检查并重新填写";
                    throw new Exception();
                } else {
                    keyMap.put(carKey, j);
                }

                List tmpList = carMoList.stream().filter(ii -> (StringUtils.equals(carBrandStr, ii.get品牌()) && StringUtils.equals(carClassStr, ii.get级别()) && StringUtils.equals(carModelStr, ii.get车型()) && StringUtils.equals(carDetailStr, ii.get车型详细()))).collect(Collectors.toList()); // 将导入数据在系统中寻找
                if (tmpList.size() == 0) {
                    logger.error("line={}, excel={}", j, carKey);
                    errMsg = "第" + j + "行车型与系统车型不对照,请检查并重新填写";
                    throw new Exception();
                }
                String scPri = StringUtils.getCellValue(row.getCell(22));
                BigDecimal scBd;
                try {
                    scBd = new BigDecimal(scPri);
                } catch (Exception e) {
                    errMsg = "第" + j + "行销售顾问权限不是合法数字";
                    throw new Exception();
                }
                String smPri =StringUtils.getCellValue(row.getCell(20));
                BigDecimal smBd;
                try {
                    smBd = new BigDecimal(smPri);
                } catch (Exception e) {
                    errMsg = "第" + j + "行销售经理权限不是合法数字";
                    throw new Exception();
                }
                String gmPri = StringUtils.getCellValue(row.getCell(18));
                BigDecimal gmBd;
                try {
                    gmBd = new BigDecimal(gmPri);
                } catch (Exception e) {
                    errMsg = "第" + j + "行总经理权限不是合法数字";
                    throw new Exception();
                }
                if (scBd.compareTo(smBd) <= 0 || smBd.compareTo(gmBd) <= 0) {
                    errMsg = "第" + j + "行权限金额设置有误,请检查并重新填写";
                    throw new Exception();
                }
                DecimalFormat df = new DecimalFormat("0.00");
                Itask基础设置Model iTaskMo1 = new Itask基础设置Model(); // mo1
                iTaskMo1.set许可(permit);
                iTaskMo1.set设置项目("step1__" + carBrand + "__" + carClass + "__" + carModelStr + "__" + carDetailStr);
                iTaskMo1.set值(df.format(scBd));
                iTaskMo1.set更新账号(user);
                iTaskMo1.set更新时间(Timestamp.valueOf(LocalDateTime.now())); // mo2
                Itask基础设置Model iTaskMo2 = new Itask基础设置Model();
                iTaskMo2.set许可(permit);
                iTaskMo2.set设置项目("step2__" + carBrand + "__" + carClass + "__" + carModelStr + "__" + carDetailStr);
                iTaskMo2.set值(df.format(smBd));
                iTaskMo2.set更新账号(user);
                iTaskMo2.set更新时间(Timestamp.valueOf(LocalDateTime.now())); // mo3
                Itask基础设置Model iTaskMo3 = new Itask基础设置Model();
                iTaskMo3.set许可(permit);
                iTaskMo3.set设置项目("step3__" + carBrand + "__" + carClass + "__" + carModelStr + "__" + carDetailStr );
                iTaskMo3.set值(df.format(gmBd));
                iTaskMo3.set更新账号(user);
                iTaskMo3.set更新时间(Timestamp.valueOf(LocalDateTime.now()));
                iTaskMoList.add(iTaskMo1);
                iTaskMoList.add(iTaskMo2);
                iTaskMoList.add(iTaskMo3);
                i++;

                //记录日志
                list.add(getSaveSnpLogsList(row));

                Row nextRow = sheet.getRow(j);
                // 没有下一行时，循环结束
                if (nextRow == null) {
                    break;
                }
                // 下一行所有数据为空时，循环结束
                if (nextRow.getCell(0) == null || nextRow.getCell(0).toString().trim().length() == 0) {
                    break;
                }
            }
            //清理之前老数据
            for (String value : permitMap.values()) {
                Integer deleteCount = itask基础设置Repository.deleteContractItemByPermit(value);
                logger.info("导入车型权限数据时，删除" + deleteCount + "条数据");
            }
            // 入库
            itask基础设置Repository.save(iTaskMoList);
            //保存日志
            snpBusinessSetLogsRepository.save(list);
            return new ResultData("true", null, null);
        } catch (Exception e) {
            logger.error(errMsg, e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return new ResultData("false", errMsg, null);
        }
    }

    /**
     * 记录导入历史
     * @param row
     */
    private  SnpBusinessSetLogs  getSaveSnpLogsList(Row row){
        String permit = StringUtils.getCellValue(row.getCell(0)); // 许可
        String carBrand = StringUtils.getCellValue(row.getCell(1)); // 品牌
        String carClass = StringUtils.getCellValue(row.getCell(2)); // 车系
        String carModel = StringUtils.getCellValue(row.getCell(3)); // 车型
        String carDetail = StringUtils.getCellValue(row.getCell(4)); // 车款
        String msrp = StringUtils.getCellValue(row.getCell(5)); // 厂家建议零售价
        String targetSaleNum = StringUtils.getCellValue(row.getCell(6)); // 预计销售台数
        String laseMonthSaleAmount = StringUtils.getCellValue(row.getCell(7)); // 上月单车销售额
        String amountUnit = StringUtils.getCellValue(row.getCell(8)); // 金额/台
        String difference = StringUtils.getCellValue(row.getCell(9)); // 与N-1月差异
        String stockNum = StringUtils.getCellValue(row.getCell(10)); // 截止当日库存台数
        String stockTurnoverDay = StringUtils.getCellValue(row.getCell(11)); // 库存周转天数
        String actSaleStock = StringUtils.getCellValue(row.getCell(12)); // N-1月实际销售台次
        String saleGp = StringUtils.getCellValue(row.getCell(13)); // N-1月平均单车综合销售毛利
        String standardGp = StringUtils.getCellValue(row.getCell(14)); // N月预计标准毛利
        String gmActRate = StringUtils.getPercentValue(StringUtils.getCellValue(row.getCell(15))); // N-1月总经理及以上权限实际占比
        String gmRequireRate = StringUtils.getPercentValue(StringUtils.getCellValue(row.getCell(16))); // N月总经理及以上权限占比要求
        String comprehensiveGp = StringUtils.getPercentValue(StringUtils.getCellValue(row.getCell(17))); // N月综合毛利率
        String gmFixedPrice = StringUtils.getCellValue(row.getCell(18)); // 总经理
        String gmGp = StringUtils.getPercentValue(StringUtils.getCellValue(row.getCell(19))); // 综合毛利率
        String saleGmFixedPrice = StringUtils.getCellValue(row.getCell(20)); // 销售经理
        String saleGmGp = StringUtils.getPercentValue(StringUtils.getCellValue(row.getCell(21))); // 综合毛利率
        String scFixedPrice =StringUtils.getCellValue(row.getCell(22)); // 销售顾问
        String scGp = StringUtils.getPercentValue(StringUtils.getCellValue(row.getCell(23))); // 综合毛利率
        String mark = StringUtils.getCellValue(row.getCell(24)); // 备注
       return new SnpBusinessSetLogs(permit,carBrand,carClass,carModel,carDetail,msrp,targetSaleNum,laseMonthSaleAmount,amountUnit,
                difference,stockNum,stockTurnoverDay,actSaleStock,saleGp,standardGp,gmActRate,gmRequireRate,comprehensiveGp,gmFixedPrice,gmGp,
                saleGmFixedPrice,saleGmGp,scFixedPrice,scGp,mark,new Date());
    }

    @Override
    public ResultData getPrivilegeForCarModel(GetPrivilegeForCarModelRequest re) {
        PageData pageData = this.pushApprovalWorkFlowRepository.getPrivilegeForCarModel(
                re.carBrand, re.carClass, re.carModel, re.getPageSize(), re.getPageIndex());
        List list = pageData.getData();
        for (Object obj : list) {
            Map<String, Object> map = (Map) obj;
            String item = (String) map.get("item");
            String val = (String) map.get("val");
            String permit = (String) map.get("dlr");
            String[] items = item.split("__");
            map.put("许可", permit);
            map.put("品牌", items[1]);
            map.put("车系", items[2]);
            map.put("车型", items[3]);
            if ("step1".equals(items[0])) {
                map.put("审批层级", "销售顾问");
            } else if ("step2".equals(items[0])) {
                map.put("审批层级", "一级审批");
            } else if ("step3".equals(items[0])) {
                map.put("审批层级", "二级审批");
            } else if ("step4".equals(items[0])) {
                map.put("审批层级", "三级审批");
            } else if ("step5".equals(items[0])) {
                map.put("审批层级", "四级审批");
            } // 其他不处理
            map.put("审批权限", val);
        }
        if (list.size() == 0) {
            return new ResultData("true", "暂无数据", null);
        } else {
            return new ResultData("true", null, pageData);
        }
    }

    @Override
    public ResultData exportPrivilegeForCarModel(GetPrivilegeForCarModelRequest re) {
        PageData pageData = this.pushApprovalWorkFlowRepository.exportPrivilegeForCarModel(
                re.carBrand, re.carClass, re.carModel, re.getPageSize(), re.getPageIndex());
        return new ResultData("true", null, pageData);

    }

    @Override
    public ResultData getPrivilegeForCarModelDealer(GetPrivilegeForCarModelRequest re, String dlr) {
        logger.info("getPrivilegeForCarModelDealer参数为:" + JsonObjectUtils.writeAsJson(re));
        PageData pageData = this.pushApprovalWorkFlowRepository
                .getPrivilegeForCarModelDealer(dlr, re.carBrand, re.carClass, re.carModel, re.getPageSize(), re.getPageIndex());
        // 补充审批人账号
        List list = pageData.getData();
        // 处理车型
        for (Object obj : list) {
            Map<String, Object> map = (Map) obj;
            String item = (String) map.get("item");
            if (item == null) {
                map.put("品牌", "");
                map.put("车系", "");
                map.put("车型", "");
            } else {
                String[] carInfo = item.split("__");
                map.put("品牌", carInfo[1]);
                map.put("车系", carInfo[2]);
                map.put("车型", carInfo[3]);
            }
        }
        // 补充角色，姓名
        for (Object obj : list) {
            Map<String, Object> map = (Map) obj;
            String account = (String) map.get("账号");
            String name = (String) map.get("姓名");
            if (name == null && account.contains("_")) { // 如果是角色审批（找不到用户名）
                map.put("角色", account.split("_")[1]);
            }
        }
        return new ResultData("true", null, pageData);
    }

    @Override
    public List getApprovalList(GetApprovalListRequest reqeust) {

        List list = this.pushApprovalWorkFlowRepository
                .getApprovalList(reqeust.permit, reqeust.type, reqeust.quotedPriceCodeOrVIN);
        // 现订现交流程修改后，会出现同报价编号的订单与合同审批，在返回审批历史的时候，因为没有传入type过滤，会同时出现，并影响正常审批
        // 判断返回的审批有几种
        Set<Integer> typeSet = new HashSet<>();
        for (Object obj : list) {
            Map map = (Map) obj;
            typeSet.add((Integer) map.get("type"));
        }
        if (typeSet.size() != 1 && typeSet.contains(1) && typeSet.contains(3)) { // 同时包含订单与合同时
            List<Map> orderLi = new ArrayList<>();
            List<Map> contractLi = new ArrayList<>();
            for (Object obj : list) { // 将数据分开
                Map map = (Map) obj;
                Integer type = (Integer) map.get("type");
                if (type == 1) {
                    orderLi.add(map);
                } else {
                    contractLi.add(map);
                }
            }
            for (Map map : orderLi) {
                if ("0".equals(map.get("approvalStatus"))) { // 订单未审批完成，显示订单
                    return orderLi;
                }
            } // 订单审批完成，显示合同
            list = contractLi;
        } // 目前除了现订现交的流程，调入调出（另一个SQL用type区分）外，不会有相同的quotedPriceCode对应不同的type
        if (list.size() == 0) { // 存在list大小为0的情况
            logger.info("getApprovalList方法返回list大小为0");
            return list;
        } else {
            // 如果是合同类审批，要去掉前面的销售顾问
            if (ApprovalUtils.isContractType((Integer) ((Map) list.get(0)).get("type"))) {
                List<Map> tmpList = new ArrayList<>();
                Stack<Map> stack = new Stack<>();
                for (int i = list.size() - 2; i >= 0; i--) {
                    // 将step后移一位
                    Map map = (Map) list.get(i);
                    Map mapNext = (Map) list.get(i + 1);
                    mapNext.put("step", map.get("step"));
                    stack.push(mapNext);
                }
                while (!stack.empty()) {
                    tmpList.add(stack.pop());
                }
                list = tmpList;
            }
        }

        //构建财务订金确认记录
        list = buildDepositStatus(typeSet,reqeust.quotedPriceCodeOrVIN,reqeust.permit,list);
        //构建车资确认记录
        list = buildCarSourceStatus(typeSet,reqeust.quotedPriceCodeOrVIN,reqeust.permit,list);
        return list;
    }

    @Override
    @Transactional
    public ResultData addApprovalWorkFlow(PushApprovalWorkFlowModel model, String liveUserName) {
        logger.info("addApprovalWorkFlow参数:" + JsonObjectUtils.writeAsJson(model) + ", liveUserName=" + liveUserName);
        String errMsg = "新建审批流水异常";
        try {
            if (model == null) {
                throw new Exception("Model is null");
            }
            String quotedPriceCodeOrVin = model.getQuotedPriceCodeOrVin();

            // 参数检验
            Integer type = model.getType();
            if (type == null) {
                logger.warn("新增审批流程传入type = null");
                return new ResultData("false", "新增审批流程失败，审批类型未知", null);
            }
            if (StringUtils.isNullOrBlank(model.getQuotedPriceCodeOrVin())) {
                logger.warn("新增审批流程传入quotedPriceCodeOrVIN = null");
                return new ResultData("false", "新增审批流程失败，参数异常。", null);
            }
            if (type != ApprovalUtils.TRANSFER_IN && type != ApprovalUtils.TRANSFER_OUT) { // 非调车流程才需要处理订金
                报价单表Model orderModel = repository报价单表.findOne(Integer.parseInt(quotedPriceCodeOrVin));
                报价订单表Model order = repository报价订单表.findOrderById(orderModel.get订单编号());
                //提交合同的时候报价订单是订单C 进入检测当前报价单中是否包含订金
                //由于task端提交合同是先改状态再生成合同审批流数据 采用查询是否生成合同审批流数据判定是否是订单C状态
                /*List<PushApprovalWorkFlowModel> agreementList = pushApprovalWorkFlowRepository2.getWorkFlowByPermitTypeId(model.getPermit(), model.getType(), quotedPriceCodeOrVin);
                if (ApprovalWorkFlowEnum.AGREEMENT == model.getType() && (null == agreementList || agreementList.size() == 0) && "否".equals(order.get是否现定现交())) {
                    boolean re = checkDepositIsOpen(model.getPermit(), quotedPriceCodeOrVin, model, orderModel.get初始报价单号());
                    if (re) {
                        order.set订单状态("订单C");
                        order.setIsDeposit(1);
                        repository报价订单表.save(order);
                        return new ResultData("true", null, null);
                    }
                }*/
            }
            // 现订现交流程中，订单审批后会生成合同流水数据，但因为接口原因，无法返回操作结果
            // 将检查步骤提前到订单流水生成的时候
            if (type != ApprovalUtils.TRANSFER_IN && type != ApprovalUtils.TRANSFER_OUT) {
                报价单表Model orderModel = repository报价单表.findOne(Integer.parseInt(quotedPriceCodeOrVin));
                报价订单表Model order = repository报价订单表.findOrderById(orderModel.get订单编号());
                if ("是".equals(order.get是否现定现交()) && type == 1) {
                    ResultData rd = contractFlowCheck(model.getPermit(), quotedPriceCodeOrVin, null);
                    if ("false".equals(rd.getResult())) {
                        return rd;
                    }
                }
            }
            logger.info("新增审批流程，传入报价编号或vin为" + model.getQuotedPriceCodeOrVin());
            // 根据预设的审批信息生成审批流
            List<PushApprovalWorkFlowModel> pList = this.pushApprovalWorkFlowRepository.constructWorkFlowModelList(
                    model.getPermit(), model.getType(), model.getQuotedPriceCodeOrVin());
            if (pList == null || pList.size() == 0) {
                errMsg = "审批流程新建失败，请先设置审批流程";
                throw new Exception();
            }
//            // 合同提交时的限制，车辆采购成本（含税），实际MSRP（含税）为0.00或1111111.00，提示返回（实际MSRP不会为null）
//            // 现订现交流程也需要限制
//            报价单表Model qMo = repository报价单表.findOne(Integer.parseInt(quotedPriceCodeOrVin));
//            报价订单表Model qoMo = repository报价订单表.findOne(qMo.get订单编号());
//            if (ApprovalUtils.CONTRACT == type || (ApprovalUtils.ORDER == type && "是".equals(qoMo.get是否现定现交()))) {
//                Lsh库存表Model sMo = lsh库存表Repository.findOne(qMo.get库存编号());
//                BigDecimal errDe1 = new BigDecimal("0.00");
//                BigDecimal errDe2 = new BigDecimal("1111111.00");
//                if(sMo.get采购价格含税() == null || sMo.get实际Msrp含税() == null){
//                    return new ResultData("false", String.format("车辆[%s]的采购成本或实际MSRP为空，请销售行政更新价格后，再提交合同审批", qMo.get库存编号()), null);
//                }
//
//                if (null == sMo.get采购价格含税() || null == sMo.get实际Msrp含税()
//                        || errDe1.compareTo(sMo.get采购价格含税()) == 0 || errDe2.compareTo(sMo.get采购价格含税()) == 0
//                        || errDe1.compareTo(sMo.get实际Msrp含税()) == 0 || errDe2.compareTo(sMo.get实际Msrp含税()) == 0) {
//                    return new ResultData("false", "该车辆的采购成本或实际MSRP不正确，请销售行政更新价格后，再提交合同审批", null);
//                }
//            }
            // 按step排序，以便组织架构审批处理中取上一个step
            pList.sort((PushApprovalWorkFlowModel p1, PushApprovalWorkFlowModel p2)
                    -> p1.getStep().compareTo(p2.getStep()));
            // 非调车流程，组织架构审批处理
            if (!type.equals(ApprovalUtils.TRANSFER_IN) && !type.equals(ApprovalUtils.TRANSFER_OUT)) {
                报价单表Model 报价单表Model = repository报价单表.findOne(Integer.parseInt(quotedPriceCodeOrVin));
                String scName = 报价单表Model.get销售顾问();
                if (ApprovalUtils.isContractType(type)) { // 合同类审批人时，一级审批人就是销售顾问
                    pList.get(0).setUserName(scName);
                }
                for (int i = 0; i < pList.size(); i++) {
                    PushApprovalWorkFlowModel pModel = pList.get(i);
                    if (pModel.getUserName().contains("_") && !setService.isRoleName(pModel.getUserName()) ) { //如果设置的审批人是部门_角色，需要转化成上级的邮箱
                        用户Model uModel;
                        // 组织架构审批中，用户名下保存的是岗位
                        String orgArch = pModel.getUserName();
                        String baseName; // 用来确定本级审批账号的用户名
                        if (orgArch.contains("财务经理")) { // 如果是财务经理，从本店随便找一个审批
                            List<用户Model> tmpUserList = 用户repository.findBy角色And许可(model.getPermit(), "财务经理");
                            if (tmpUserList == null || tmpUserList.size() == 0) {
                                return new ResultData("false", "找不到任何财务经理", null);
                            } else {
                                uModel = tmpUserList.get(0);
                            }
                        } else {
                            if ((ApprovalUtils.STEP + 1).equals(pModel.getStep())) { // 一级审批人是架构审批时，取销售顾问的上级
                                baseName = scName;
                            } else { // 其他级别审批人是架构审批时，取上一个step的上级
                                baseName = pList.get(i - 1).getUserName();
                                int j = i - 1;
                                for (; j >= 0; j--) {
                                    String role = 用户repository.findRoleByUsername(baseName);
                                    if (role != null && "财务经理".equals(role.trim())) { // 如果baseName是财务经理账号，继续往前找
                                        baseName = pList.get(j).getUserName();
                                    } else { // 非财务经理账号，baseName不处理
                                        break;
                                    }
                                }
                                if (j == -1) { // 如果在审批人中全是财务经理，用销售顾问账号作为baseName
                                    baseName = scName;
                                }
                            }
                            // 按用户组织架构获取当前流程用户上级领导
                            uModel = getSuperiorByOrgArchAndUser(orgArch, baseName);
                            String role = orgArch.split("_")[1];
                            if (uModel == null)
                                return new ResultData("false", "用户" + baseName + "找不到上级审批角色：" + role + "，请联系销售行政进行设置，用户可能已删除。", null);
                        }
                        pModel.setUserName(uModel.get用户名());
                        logger.info(orgArch + "替换审批人账号为" + uModel.get用户名());
                    } // 审批人是邮箱名时，不作处理
                }
            }
            logger.warn(String.format("审批流程调整未处理前，审批流水=%s", JsonObjectUtils.writeAsJson(pList)));
            if (ApprovalUtils.isContractType(type)) { // 合同类流程
                ResultData tmpRd = ApprovalUtils.adjustApprovalFlowRco(pList);
                if ("false".equals(tmpRd.getResult())) { // 如果调整审批流水异常，返回
                    return tmpRd;
                } else { // 如果调整流水正常，将销售顾问的审批状态改为9, 如果流水中只有一级，表示不需要审批，直接走后处理
                    pList = tmpRd.getPageData().getData();
                    pList.get(0).setApprovalStatus("9");
                    if (pList.size() == 1) { // 如果审批流水只有1级
                        报价单表Model 报价单表Model = repository报价单表.findOne(Integer.parseInt(quotedPriceCodeOrVin));
                        if (checkSource(pList, 报价单表Model)) { // 如果添加资源确认数据，方法返回
                            this.approvalRepository.save(pList);
                            return new ResultData("true", null, null);
                        } else { // 如果不需要资源确认，直接走后处理
                            switch (type) {
                                case ApprovalUtils.CONTRACT:
                                    postContractProcess(pList, "step1", "1", DefaultValueConstant.CHECK_CAR_SOURCE_OUT);
                                    break;
                                case ApprovalUtils.CONTRACT_MODIFY:
                                    postContractModifyProcess(pList, "step1", "1", DefaultValueConstant.CHECK_CAR_SOURCE_OUT);
                                    break;
                                case ApprovalUtils.INVOICE_MODIFY:
                                    postChangeTicketProcess(pList, "step1", "1", DefaultValueConstant.CHECK_CAR_SOURCE_OUT);
                                    break;
                                default:
                                    errMsg = "不支持的审批类型";
                                    throw new Exception();
                            }
                        }
                    }
                }
            }
            logger.warn(String.format("审批流程调整处理后，审批流水=%s", JsonObjectUtils.writeAsJson(pList)));
            this.approvalRepository.save(pList);
            // 调车审批没有销售顾问
            logger.info(String.format("消息发送。quotedPriceCodeOrVIN=%s", model.getQuotedPriceCodeOrVin()));
            if (8 != model.getType() && 9 != model.getType()) {
                报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(model.getQuotedPriceCodeOrVin()));
                if (model报价单表 != null) {
                    String[] typeDetermine = {null, "订单", "意向订单", "合同", "订单退订", "意向订单退订", "订单修改", "意向订单修改"
                            , "调车调入", "调车调出", "合同修改", "合同退订", "换票", "退票"};
                    String[] msgType = {null, "订单", "订单", "合同", "订单", "订单", "订单", "订单"
                            , "调车调入", "调车调出", "合同", "合同", "合同", "合同"};

                    顾客记录汇总Model model汇总 = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
                    if (model汇总 == null) {
                        throw new AppException(String.format("找不到【%s】对应的顾客汇总记录", model报价单表.get顾客编号()));
                    }
                    String firstUserName;
                    if (pList.size() > 1&&ApprovalUtils.isContractType(type)) { // 如果存在，给二级审批人发消息
                        firstUserName = pList.get(1).getUserName();
                    }else{
                        firstUserName = pList.get(0).getUserName();
                    }

                    List appList = new ArrayList();
                    appList.add(firstUserName);
                    if (StringUtils.isNullOrBlank(model汇总.get顾客姓名())) {
                        model汇总.set顾客姓名("无");
                    }
                    if (StringUtils.isNullOrBlank(model汇总.get电话号码())) {
                        model汇总.set电话号码("无");
                    }
                    String content = "新的" + typeDetermine[model.getType()] + "申请需要您审批,客户姓名：" +
                            model汇总.get顾客姓名() + "，顾客电话：" + model汇总.get电话号码();
                    LshMsgUtils.getLshMsg(model报价单表.get许可(), liveUserName, model报价单表.get许可(), firstUserName, msgType[model.getType()], content, liveUserName, model汇总.get电话号码());
                    JPush.sendPushForAndroidAndIos(content, content,
                            JsonObjectUtils.getJsonObject(model.getType().toString(), "", model.getQuotedPriceCodeOrVin(), "",
                                    model报价单表.get顾客编号().toString(), model报价单表.get销售顾问()),
                            appList, JPush.Platforms.iMgt);
                    //给销售顾问发消息
                    List scList = new ArrayList();
                    scList.add(model报价单表.get销售顾问());
                    String contentMsg = "申请审批提交成功!客户姓名：" + model汇总.get顾客姓名() + "，客户电话：" + model汇总.get电话号码() + "，请等待订单审批全部通过。";
                    LshMsgUtils.getLshMsg(model报价单表.get许可(), liveUserName, model报价单表.get许可(), model报价单表.get销售顾问(), msgType[model.getType()],
                            typeDetermine[model.getType()] + contentMsg, liveUserName, model汇总.get电话号码());
                    JPush.sendPushForAndroidAndIos(contentMsg, contentMsg,
                            JsonObjectUtils.getJsonObject(model.getType().toString(), "通过", model.getQuotedPriceCodeOrVin(), "",
                                    model报价单表.get顾客编号().toString(), model报价单表.get销售顾问()),
                            scList, JPush.Platforms.iTask);
                }
            } else {
                String firstUserName = pList.get(0).getUserName();
                CarTransferLogModel carLog = carTransferLogRepository.findOne(Integer.parseInt(model.getQuotedPriceCodeOrVin()));
                if (carLog == null) {
                    throw new AppException("找不到调车记录！调车id：" + model.getQuotedPriceCodeOrVin());
                }
                Lsh库存表Model model库存表 = lsh库存表Repository.findOne(carLog.getStockCode());
                if (model库存表 == null) {
                    throw new AppException("没有找到库存信息！车架号：" + model.getQuotedPriceCodeOrVin());
                }
                if (8 == model.getType()) {
                    //调车审批给第一级审批人发消息
                    String customer = carLog.getCustomName();
                    String mobile = carLog.getCustomTel();
                    if (StringUtils.isNullOrBlank(carLog.getCustomName())) {
                        customer = "无";
                    }
                    if (StringUtils.isNullOrBlank(carLog.getCustomTel())) {
                        mobile = "无";
                    }
                    String firstMsg = "有新的调车调入审批需要您审批，客户姓名：" + customer + "，客户电话：" + mobile;
                    LshMsgUtils.getLshMsg(model库存表.get调入经销商(), liveUserName, model库存表.get调入经销商(), firstUserName, "调车调入",
                            firstMsg, liveUserName, carLog.getCustomTel());
                    List appList = new ArrayList();
                    appList.add(firstUserName);
                    JPush.sendPushForAndroidAndIos(firstMsg, firstMsg,
                            JsonObjectUtils.getJsonObject(model.getType().toString(), "", model.getQuotedPriceCodeOrVin(), "",
                                    "", ""),
                            appList, JPush.Platforms.iMgt);

                    //给销售行政发消息
                    LshMsgUtils.getLshMsg(model库存表.get调入经销商(), liveUserName, model库存表.get调入经销商(), carLog.getInternalApplyUser(), "调车调入",
                            "您提交的调车调入申请提交成功！，客户姓名：" + customer + "，客户电话：" + mobile, liveUserName, carLog.getCustomTel());

                }
                if (9 == model.getType()) {
                    LshMsgUtils.getLshMsg(model库存表.get调入经销商(), liveUserName, model库存表.get调出经销商(), firstUserName, "调车调出",
                            "有新的调车调出审批需要您审批", liveUserName, carLog.getCustomTel());
                    List appList = new ArrayList();
                    appList.add(firstUserName);
                    JPush.sendPushForAndroidAndIos("有新的调车调出需要您审批", "有新的调车调出需要您审批",
                            JsonObjectUtils.getJsonObject(model.getType().toString(), "有新的调车调出需要您审批", model.getQuotedPriceCodeOrVin(), "",
                                    "", ""),
                            appList, JPush.Platforms.iMgt);
                }
            }
            return new ResultData("true", null, null);
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error(errMsg, e);
            return new ResultData("false", errMsg, null);
        }
    }

    // 根据用户名与设置的上级审批角色找到相应的Model
    private 用户Model getSuperiorByOrgArchAndUser(String orgArch, String username) {
        用户Model bModel = repository用户.findModelByUsername(username);
        if (bModel == null) {
            return null;
        }
        int i = 0;
        用户Model suModel;
        for (; i < 20; i++) { // 循环20次，找不到就返回null，因为用户设置的数据，可能出现逻辑错误的环状组织树
            String superior = bModel.getSuperior();
            if ("".equals(superior)) { // 没有上级审批人
                logger.warn(bModel.get用户名() + "上级审批人没有设置");
                return null;
            } else {
                suModel = repository用户.findModelByUsername(superior);
                if (suModel.get角色().equals(orgArch.split("_")[1])) { // 找到匹配的上级（属于基础用户的直接或间接上级，且岗位与设置相同）
                    return suModel;
                } else { // 找不到匹配的上级，继续往上找
                    bModel = suModel;
                }
            }
        }

        if (i == 20) {
            logger.warn("找不到设置的上级审批人账号，设置的岗位为" + orgArch + "，基础用户为" + username);
        }
        return null;
    }

    /**
     * 修改审批流水条目
     *
     * @param list                       前端传的审批历史
     * @param current_step               当前审批步骤
     * @param SNP                        无用字段
     * @param expectedLateMoneyInAccount 无用字段
     * @return 正确与否标识
     * @throws Exception
     */
    @Override
    @Transactional
    public boolean modifyApprovalWorkFlowById(List<PushApprovalWorkFlowModel> list, String current_step, String SNP,
                                              String expectedLateMoneyInAccount) throws Exception {
        RunTrack track = new RunTrack();
        try {
            if (list == null || list.isEmpty() || current_step == null) {
                logger.warn("modifyApprovalWorkFlowById方法参数为null");
                return false;
            }

            track.add(String.format("list=%s, current_step=%s, expectedLateMoneyInAccount=%s", JsonObjectUtils.writeAsJson(list), current_step, expectedLateMoneyInAccount));

            // 取出当前审批人的索引
            int i = getCurrentStep(list, current_step);
            // 取出最后一位审批人的索引
            String maxStep = maxStep(list);
            int j = getCurrentStep(list, maxStep);
            track.add(String.format("当前审批索引：%d, 最后审批索引：%d", i, j));

            // 将当前审批条目保存
            PushApprovalWorkFlowModel entity = approvalRepository.findOne(list.get(i).getId());
            if (entity == null) {
                throw new Exception(String.format("审批条目【%s】不存在。", list.get(i).getId()));
            }

            track.add("开始保存当前审批。");
            entity.setRemark(list.get(i).getRemark());
            String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
            entity.setProcessTime(Timestamp.valueOf(time));
            String approvalStatus = list.get(i).getApprovalStatus();
            entity.setApprovalStatus(approvalStatus);
            approvalRepository.save(entity);
            track.add("保存当前审批成功。");

            // 补上时间为后面的调用作准备
            list.get(0).setProcessTime(Timestamp.valueOf(time));

            //审批条目保存后给销售顾问发送消息
            报价单表Model 报价单表Model;
            Lsh库存表Model lsh库存表Model;
            String contentSales;
            String typeDetermine = null;
            String msgType = null;

            //判断要发送的 消息分类 及  审批流水类型
            switch (list.get(i).getType()) {
                case 1: // 订单
                    typeDetermine = "订单";
                    msgType = "订单";
                    break;
                case 2: // 意向订单
                    typeDetermine = "意向订单";
                    msgType = "订单";
                    break;
                case 3: // 合同
                    typeDetermine = "合同";
                    msgType = "合同";
                    break;
                case 4: // 订单退订
                    typeDetermine = "订单退订";
                    msgType = "订单";
                    break;
                case 5: // 意向订单退订
                    typeDetermine = "意向订单退订";
                    msgType = "订单";
                    break;
                case 6: // 订单修改
                    typeDetermine = "订单修改";
                    msgType = "订单";
                    break;
                case 7: // 意向订单修改
                    typeDetermine = "意向订单修改";
                    msgType = "订单";
                    break;
                case 10: // 合同
                    typeDetermine = "合同修改";
                    msgType = "合同";
                    break;
//                case 11:
//                    typeDetermine = "合同退订";
//                    msgType = "合同";
//                    break;
                case 12: // 换票
                    typeDetermine = "换票";
                    msgType = "合同";
                    break;
                case 13: // 退票
                    typeDetermine = "退票";
                    msgType = "合同";
                    break;
            }

            报价单表Model = repository报价单表.findOne(Integer.parseInt(list.get(0).getQuotedPriceCodeOrVin()));
            报价订单表Model  order = repository报价订单表.findOrderById(报价单表Model.get订单编号());

            //财务订金确认流程 订单/意向订单最后一级审批包含订金或者订单/意向订单修改订金有变更 非现定现交触发流程
            if (i == j && ApprovalUtils.isFinancialDepositType(list.get(0).getType()) && "1".equals(list.get(j).getApprovalStatus())){
                if ("否".equals(order.get是否现定现交())) {
                    boolean re = checkDepositIsOpen(list.get(j).getPermit(), list.get(j).getQuotedPriceCodeOrVin(), list.get(j), 报价单表Model.get初始报价单号());
                    //在报价订单记录中写入财务订金待确认标志
                    if(re){
                        order.setIsDeposit(1);
                        repository报价订单表.save(order);
                    }
                }
            }

            //车资确认审批流程
            if (i == j
                    && ApprovalUtils.isContractType(list.get(0).getType())
                    && "1".equals(list.get(j).getApprovalStatus())) { // 最后一级，合同类，通过
                if (checkSource(list, 报价单表Model)) { // 如果添加资源确认数据，方法返回
                    return true;
                } // 资源确认设置不存在，或不需要资源确认，或之前进行过确认，返回false
            } // 其他情况，继续判断后处理与消息

            track.add("审批后处理。");
            // 如果最后一级审批通过，或者当前级别驳回，进入后处理
            if ("1".equals(list.get(j).getApprovalStatus()) || "2".equals(list.get(i).getApprovalStatus())) {
                // 后处理
                switch (list.get(0).getType()) {
                    case ApprovalWorkFlowEnum.ORDER: // 订单
                        postOrderProcess(list, current_step, approvalStatus);
                        break;
                    case ApprovalWorkFlowEnum.ORDER_INTENTION: // 意向订单
                        postIntentOrderProcess(list, current_step, approvalStatus);
                        break;
                    case ApprovalWorkFlowEnum.AGREEMENT: // 合同
                        postContractProcess(list, current_step, approvalStatus, DefaultValueConstant.CHECK_CAR_SOURCE_OUT);
                        break;
                    case ApprovalWorkFlowEnum.ORDER_RETREAT: // 订单退订
                        postOrderWithdrawProcess(list, current_step, approvalStatus);
                        break;
                    case ApprovalWorkFlowEnum.ORDER_INTENTION_RETREAT: // 意向订单退订
                        postIntentOrderWithdrawProcess(list, current_step, approvalStatus);
                        break;
                    case ApprovalWorkFlowEnum.ORDER_UPDATE: // 订单修改
                        postOrderModifyProcess(list, current_step, approvalStatus);
                        break;
                    case ApprovalWorkFlowEnum.ORDER_INTENTION_UPDATE: // 意向订单修改
                        postIntentOrderModifyProcess(list, current_step, approvalStatus);
                        break;
                    case ApprovalWorkFlowEnum.AGREEMENT_UPDATE: // 合同修改
                        postContractModifyProcess(list, current_step, approvalStatus, DefaultValueConstant.CHECK_CAR_SOURCE_OUT);
                        break;
                    case ApprovalWorkFlowEnum.AGREEMENT_RETREAT: //合同退订+324——1
                        postContractWithdrawProcess(list, current_step, approvalStatus, DefaultValueConstant.CHECK_CAR_SOURCE_OUT);
                        break;
                    case ApprovalWorkFlowEnum.TICKET_CHANG: //换票+324——2
                        postChangeTicketProcess(list, current_step, approvalStatus, DefaultValueConstant.CHECK_CAR_SOURCE_OUT);
                        break;
                    case ApprovalWorkFlowEnum.TICKET_RETREAT: //退票+324——3
                        postTicketWithdrawProcess(list, current_step, approvalStatus, DefaultValueConstant.CHECK_CAR_SOURCE_OUT);
                        break;
                }
            }

            track.add("审批结束。");

            // case.1 非最后一级审批通过时，判断下一级审批人，在前面的审批流程中有没有出现过，出现则自动处理
            if (i < j && ApprovalUtils.AGREE.equals(list.get(i).getApprovalStatus())) {
                String nextStep = ApprovalUtils.STEP + (Integer.parseInt(current_step.substring(4, 5)) + 1);
                PushApprovalWorkFlowModel moK = list.get(i + 1); // 下一个step的model
                for (int n = 0; n <= i; n++) { // 从第一级开始到本级
                    if (list.get(n).getUserName().equals(moK.getUserName())) { // 如果下一级审批人，在前面的审批中已经处理过
                        moK.setApprovalStatus("1");
                        moK.setRemark("自动处理");
                        moK.setProcessTime(Timestamp.valueOf(LocalDateTime.now()));
                        modifyApprovalWorkFlowById(list, nextStep, null, expectedLateMoneyInAccount); // 将下级审批人也通过处理
                    }
                }
            } // 最后一级审批，或驳回就不用判断了

            // case.2现订现交流程中，自动处理跨过订单，合同两个审批流，要细化讨论
            报价订单表Model orMo = repository报价订单表.findOne(报价单表Model.get订单编号());
            if ("是".equals(orMo.get是否现定现交())) { // 如果是现订现交流程
                if (ApprovalUtils.ORDER == list.get(0).getType()) { // 如果是订单阶段
                    if (i == j && ApprovalUtils.AGREE.equals(list.get(i).getApprovalStatus())) { // 在最后一级审批通过时，无论是否自动通过，都要判断合同一级是否需要自动通过
                        List<PushApprovalWorkFlowModel> conMoLi = pushApprovalWorkFlowRepository2.getWorkFlowByPermitTypeId(
                                list.get(0).getPermit(), ApprovalUtils.CONTRACT,
                                list.get(0).getQuotedPriceCodeOrVin()); // 找到对应的合同审批流
                        PushApprovalWorkFlowModel moK = conMoLi.get(0); // 合同一级model
                        for (PushApprovalWorkFlowModel mo : list) {
                            if (mo.getUserName().equalsIgnoreCase(conMoLi.get(0).getUserName())) { // 如果合同一级审批人之前处理过
                                moK.setApprovalStatus("1");
                                moK.setRemark("自动处理");
                                moK.setProcessTime(Timestamp.valueOf(LocalDateTime.now()));
                                modifyApprovalWorkFlowById(conMoLi, ApprovalUtils.STEP + 1, null, expectedLateMoneyInAccount); // 将下级审批人也通过处理
                            }
                        }
                    } // 其他级别走case.1的流程，驳回不管
                } else if (ApprovalUtils.CONTRACT == list.get(0).getType()) { // 如果是合同阶段
                    // case.1处理了合同中的同名情况，这里把订单的补上
                    if (i < j && ApprovalUtils.AGREE.equals(list.get(i).getApprovalStatus())) { // 非最后一级审批且通过时
                        String nextStep = ApprovalUtils.STEP + (Integer.parseInt(current_step.substring(4, 5)) + 1);
                        PushApprovalWorkFlowModel moK = list.get(i + 1); // 下一个step的model
                        List<PushApprovalWorkFlowModel> orMoLi = pushApprovalWorkFlowRepository2.getWorkFlowByPermitTypeId(
                                list.get(0).getPermit(), ApprovalUtils.ORDER,
                                list.get(0).getQuotedPriceCodeOrVin()); // 找到对应的订单审批流
                        for (PushApprovalWorkFlowModel mo : orMoLi) {
                            if (mo.getUserName().equalsIgnoreCase(moK.getUserName())) { // 如果下级审批人，在订单中已经处理过
                                moK.setApprovalStatus("1");
                                moK.setRemark("自动处理");
                                moK.setProcessTime(Timestamp.valueOf(LocalDateTime.now()));
                                modifyApprovalWorkFlowById(list, nextStep, null, expectedLateMoneyInAccount); // 将下级审批人也通过处理
                            }
                        }
                    } // 最后一级或驳回不处理
                }
            }

            //消息处理
            track.add(String.format("开始发送消息：typeDetermine=%s, msgType=%s}", typeDetermine, msgType));
            PushApprovalWorkFlowModel ph = list.get(i);//当前审批流水条目
            if ((list.get(i).getType() == 8 || list.get(i).getType() == 9) && "1".equals(approvalStatus)) {
//                if ("1".equals(approvalStatus)) {
//                    //先根据车架号查询到库存表
//                    lsh库存表Model = lsh库存表Repository.findLshRecordByVin(ph.getQuotedPriceCodeOrVin());
//                    if (lsh库存表Model != null) {
//                        Lsh车型Model lsh车型Model = lsh车型Repository.findOne(lsh库存表Model.get车型编号());
//                        if (lsh车型Model != null) {
//                            //在根据库存表的订单编号查询到car_transfer_log表
//                            List<CarTransferLogModel> carTransferLogModelList = carTransferLogRepository.findByStockId(lsh库存表Model.get库存编号());
//                            CarTransferLogModel carLog = carTransferLogModelList.get(0);
//                            if (StringUtils.isNullOrBlank(carLog.getCustomName())) {
//                                carLog.setCustomName("无");
//                            }
//                            if (StringUtils.isNullOrBlank(carLog.getCustomTel())) {
//                                carLog.setCustomTel("无");
//                            }
//                            if (carLog != null) {
//                                if (ph.getType() == 8) {
//                                    carLog.setInternalApprovalDate(java.sql.Date.valueOf(LocalDate.now()));
//                                    carLog.setInternalApprovalUser(ph.getUserName());
//                                    carTransferLogRepository.save(carLog);
//
//                                    //调入审批(不包括最后一级审批)需要向下一级审批人发送消息
//                                    //判断：如果当前审批人不是最后一级审批人，则发送消息
//                                    if (!maxStep.equals(ph.getStep())) {
//                                        PushApprovalWorkFlowModel phNext = list.get(i + 1);//下一级审批流水条目
//                                        //给审批人发
//                                        String stepNum = ph.getStep().substring(4);
//                                        String contentToStepNext = "生产号为" + lsh库存表Model.get生产号() + ",车款为" + lsh车型Model.get车型详细() + "的调车调入" + stepNum + "级审批已通过,客户姓名：" +
//                                                carLog.getCustomName() + ",顾客电话：" + carLog.getCustomTel();
//                                        LshMsgUtils.getLshMsg(ph.getPermit(), ph.getUserName(), phNext.getPermit(), phNext.getUserName(), "调车调入", contentToStepNext,
//                                                ph.getUserName(), carLog.getCustomTel());
//                                        List appList = new ArrayList();
//                                        appList.add(phNext.getUserName());
//                                        JPush.sendPushForAndroidAndIos(contentToStepNext, contentToStepNext,
//                                                JsonObjectUtils.getJsonObject(ph.getType().toString(), "1", ph.getQuotedPriceCodeOrVin(), "",
//                                                        "", ""),
//                                                appList, JPush.Platforms.iMgt);
//                                        //给销售行政发
//                                        LshMsgUtils.getLshMsg(ph.getPermit(), ph.getUserName(), ph.getPermit(), carLog.getInternalApplyUser(), "调车调入", contentToStepNext,
//                                                ph.getUserName(), carLog.getCustomTel());
//                                    }
//                                } else {
//                                    //状态为9时，保存审批人传入的最晚款项到账
//                                    if (expectedLateMoneyInAccount != null && !"".equals(expectedLateMoneyInAccount)) {
//                                        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
//                                        Date utildate = sf.parse(expectedLateMoneyInAccount);
//                                        java.sql.Date sqldate = new java.sql.Date(DateFormatUtils.getFormatDate("yyyy-MM-dd", utildate).getTime());
//                                        carLog.setExpectedLateMoneyInAccount(sqldate);
//                                    }
//                                    carLog.setExternalApplyDate(java.sql.Date.valueOf(LocalDate.now()));
//                                    carLog.setExternalApplyUser(list.get(i).getUserName());
//                                    carTransferLogRepository.save(carLog);
//
//                                    //调出审批(不包括最后一级审批)需要向下一级审批人发送消息
//                                    //判断：如果当前审批人不是最后一级审批人，则发送消息
//                                    if (!maxStep.equals(ph.getStep())) {
//                                        PushApprovalWorkFlowModel phNext = list.get(i + 1);//下一级审批流水条目
//                                        String stepNum = ph.getStep().substring(4);
//                                        String contentToStepNext = "生产号为" + lsh库存表Model.get生产号() + "的调车调出" + stepNum + "级审批已通过";
//                                        LshMsgUtils.getLshMsg(ph.getPermit(), ph.getUserName(), phNext.getPermit(), phNext.getUserName(), "调车调出", contentToStepNext,
//                                                ph.getUserName(), carLog.getCustomTel());
//                                        List appList = new ArrayList();
//                                        appList.add(phNext.getUserName());
//                                        JPush.sendPushForAndroidAndIos(contentToStepNext, contentToStepNext,
//                                                JsonObjectUtils.getJsonObject(ph.getType().toString(), "1", ph.getQuotedPriceCodeOrVin(), "",
//                                                        "", ""),
//                                                appList, JPush.Platforms.iMgt);
//                                    }
//                                }
//                            } else {
//                                track.add(String.format("未找到【%s】调车日志记录记录", lsh库存表Model.get车型编号()));
//                            }
//                        } else {
//                            track.add(String.format("未找到【%s】车型记录", lsh库存表Model.get车型编号()));
//                        }
//                    } else {
//                        track.add(String.format("未找到【%s】库存记录", ph.getQuotedPriceCodeOrVin()));
//                    }
//                }
            } else if ((list.get(i).getType() != 8 && list.get(i).getType() != 9) && "1".equals(approvalStatus)) {
                报价单表Model = repository报价单表.findOne(Integer.parseInt(list.get(0).getQuotedPriceCodeOrVin()));
                String createTime = entity.getTranscationCode().substring(entity.getTranscationCode().length() - 19);
                createTime = createTime.substring(0, 4) + "年" + createTime.substring(5, 7) + "月" + createTime.substring(8, 10) + "日";
                //给销售顾问发消息
                Lsh车型Model lsh车型Model = lsh车型Repository.findOne(报价单表Model.get车型编号());
                String stepNum;
                if (list.get(i).getUserName().equals(list.get(j).getUserName())) {
                    //如果是最后一级审批人通过
                    stepNum = "全部";
                } else {
                    stepNum = list.get(i).getStep().substring(4) + "级";
                }

                顾客记录汇总Model model顾客记录汇总 = repository顾客记录汇总.findOne(报价单表Model.get顾客编号());
                if (StringUtils.isNullOrBlank(model顾客记录汇总.get顾客姓名())) {
                    model顾客记录汇总.set顾客姓名("无");
                }
                if (StringUtils.isNullOrBlank(model顾客记录汇总.get电话号码())) {
                    model顾客记录汇总.set电话号码("无");
                }
                contentSales = "您于" + createTime +
                        "提交的车款为" + (StringUtils.isNullOrBlank(lsh车型Model.get车型详细()) ? lsh车型Model.get车型() : lsh车型Model.get车型详细()) +
                        "外观为" + (报价单表Model.get外观()!=null?报价单表Model.get外观():"无") +
                        "的审批申请于" + new SimpleDateFormat("yyyy年MM月dd日").format(entity.getProcessTime().getTime()) +
                        "的" + typeDetermine +
                        "已通过" + stepNum + "审批,客户姓名：" + model顾客记录汇总.get顾客姓名() + "，客户电话：" + model顾客记录汇总.get电话号码();

                LshMsgUtils.getLshMsg(entity.getPermit(), entity.getUserName(), 报价单表Model.get许可(), 报价单表Model.get销售顾问(),
                        msgType, contentSales, entity.getUserName(), model顾客记录汇总.get电话号码());
                List appList = new ArrayList();
                appList.add(报价单表Model.get销售顾问());
                JPush.sendPushForAndroidAndIos(contentSales, contentSales,
                        JsonObjectUtils.getJsonObject(ph.getType().toString(), "1", ph.getQuotedPriceCodeOrVin(), "",
                                "", ""),
                        appList, JPush.Platforms.iTask);

                if (!maxStep.equals(list.get(i).getStep())) {
                    报价单表Model = repository报价单表.findOne(Integer.parseInt(list.get(0).getQuotedPriceCodeOrVin()));
                    顾客记录汇总Model r = repository顾客记录汇总.findOne(报价单表Model.get顾客编号());
                    if (StringUtils.isNullOrBlank(r.get顾客姓名())) {
                        r.set顾客姓名("无");
                    }
                    if (StringUtils.isNullOrBlank(r.get电话号码())) {
                        r.set电话号码("无");
                    }
                    stepNum = list.get(i).getStep().substring(4);
                    String contentNextLevel = typeDetermine + "审批已通过" + stepNum + "级审批，请留意车款为" + lsh车型Model.get车型详细() +
                            ",顾客姓名：" + r.get顾客姓名() + ",顾客电话：" + r.get电话号码() + "的" + typeDetermine + "审批";
                    LshMsgUtils.getLshMsg(entity.getPermit(), entity.getUserName(), list.get(i + 1).getPermit(), list.get(i + 1).getUserName(),
                            msgType, contentNextLevel, entity.getUserName(), r.get电话号码());
                    appList.clear();
                    appList.add(list.get(i + 1).getUserName());
                    JPush.sendPushForAndroidAndIos(contentNextLevel, contentNextLevel,
                            JsonObjectUtils.getJsonObject(ph.getType().toString(), "1", ph.getQuotedPriceCodeOrVin(), "",
                                    "", ""),
                            appList, JPush.Platforms.iMgt);
                }
            }

            return true;
        } finally {
            logger.info(JsonObjectUtils.writeAsJson(track));
        }
    }

    // 取出list中最大的step
    private String maxStep(List<PushApprovalWorkFlowModel> list) {
        if (list == null || list.size() == 0) {
            return null;
        }
        String maxStep = "0";
        for (PushApprovalWorkFlowModel model : list) {
            if (maxStep.compareTo(model.getStep()) < 0) {
                maxStep = model.getStep();
            }
        }
        return maxStep;
    }

    // 根据step得出list中的位置
    private int getCurrentStep(List<PushApprovalWorkFlowModel> list, String step) throws Exception {
        if (list == null || list.isEmpty()) return 0;

        int i;
        for (i = 0; i < list.size(); i++) {
            if (list.get(i).getStep().trim().equalsIgnoreCase(step.trim())) {
                break;
            }
        }

        if (i >= list.size()) {
            logger.warn("找不到审批流程.list={}, step={}", JsonObjectUtils.writeAsJson(list), step);
            throw new Exception("找不到审批流程.");
        }

        return i;
    }

    private boolean saleAminCarResourceCheckProcess(List<PushApprovalWorkFlowModel> list) {
        // 合同审批完成后，需要检查，是否还需要销售行政来确认资源情况
        Itask基础设置ModelPK baseMoPk = new Itask基础设置ModelPK();
        baseMoPk.set许可(list.get(0).getPermit());
        baseMoPk.set设置项目("订单审批销售行政资源确认");
        Itask基础设置Model baseMo = itask基础设置Repository.findOne(baseMoPk);
        if (baseMo == null) {
            baseMo = new Itask基础设置Model();
            baseMo.set许可(list.get(0).getPermit());
            baseMo.set设置项目("订单审批销售行政资源确认");
            baseMo.set值("0");
            itask基础设置Repository.save(baseMo);
            return false;
        }
        // 需要销售行政确认时，往sale_admin_car_resource_check中放入记录
        if ("1".equals(baseMo.get值())) {
            报价单表Model 报价单表Model = repository报价单表.findOne(Integer.parseInt(list.get(0).getQuotedPriceCodeOrVin()));
            Lsh库存表Model lsh库存表Model = lsh库存表Repository.findOne(报价单表Model.get库存编号());
            SaleAdminCarResourceCheckModel saleModel = saleAdminCarResourceCheckRepository.getByQuotedPriceCode(Integer.parseInt(list.get(0).getQuotedPriceCodeOrVin()));

            //1.第一次有资源确认之后，换票不需要资源确认（这里判断为了防止第一次没有勾选需要资源确认，换票之后勾选资源确认的情况）
            if(12==list.get(0).getType()||10==list.get(0).getType()){
                List<Integer> stockNumberList = repository报价单表.getContractStockNumber(Integer.parseInt(list.get(0).getQuotedPriceCodeOrVin()));
                if(stockNumberList!=null&&stockNumberList.size()>0){
                    if(报价单表Model.get库存编号().equals(stockNumberList.get(0))){
                        return false;
                    }
                }
            }

            if (saleModel == null) {
                SaleAdminCarResourceCheckModel saleAdminCarResourceCheckModel = new SaleAdminCarResourceCheckModel();
                saleAdminCarResourceCheckModel.setTranscationCode(list.get(0).getTranscationCode());
                saleAdminCarResourceCheckModel.setQuotedPriceCode(Integer.parseInt(list.get(0).getQuotedPriceCodeOrVin()));
                saleAdminCarResourceCheckModel.setCarCode(lsh库存表Model.get车型编号());
                saleAdminCarResourceCheckModel.setCheckStatus("00");
                saleAdminCarResourceCheckRepository.save(saleAdminCarResourceCheckModel);
            }
            return true;
        } else {
            return false;
        }
    }

    @Override
    public ResultData getSaleAdminCheckList(String permit, String username, GetSaleAdminCheckList getSaleAdminCheckList) {
        ResultData resultData = new ResultData("false", null, null);
        try {
            if (getSaleAdminCheckList != null) {
                PageData pageData = this.pushApprovalWorkFlowRepository.getSaleAdminCheckList(permit, username, getSaleAdminCheckList);
                resultData.setResult("true");
                resultData.setPageData(pageData);
            } else {
                resultData.setMessage("未获取查询参数");
            }
        } catch (Exception e) {
            logger.error("获取销售行政资源确认列表程序异常", e);
        }
        return resultData;
    }

    @Override
    @Transactional
    public boolean saleAdminCarResourceCheck(SaleAdminCarResourceCheckModel model) {
        try {
            this.saleAdminCarResourceCheckRepository.save(model);
            // 销售行政资源确认后，走合同审批后处理流程
            List<PushApprovalWorkFlowModel> l = pushApprovalWorkFlowRepository2.getModelByTransactionCode(model.getTranscationCode());
            String maxStep = "step0";
            for (PushApprovalWorkFlowModel m : l) {
                if (maxStep.compareTo(m.getStep()) < 0) {
                    maxStep = m.getStep();
                }
            }
            Integer type = l.get(0).getType();
            switch (type) {
                case ApprovalWorkFlowEnum.AGREEMENT:
                    postContractProcess(l, maxStep, "1", DefaultValueConstant.CHECK_CAR_SOURCE_IN);//合同
                    break;
                case ApprovalWorkFlowEnum.AGREEMENT_UPDATE:
                    postContractModifyProcess(l, maxStep, "1", DefaultValueConstant.CHECK_CAR_SOURCE_IN);//合同修改
                    break;
                case ApprovalWorkFlowEnum.AGREEMENT_RETREAT:
                    postContractWithdrawProcess(l, maxStep, "1", DefaultValueConstant.CHECK_CAR_SOURCE_IN);//合同退订
                    break;
                case ApprovalWorkFlowEnum.TICKET_CHANG:
                    postChangeTicketProcess(l, maxStep, "1", DefaultValueConstant.CHECK_CAR_SOURCE_IN);//换票
                    break;
                case ApprovalWorkFlowEnum.TICKET_RETREAT:
                    postTicketWithdrawProcess(l, maxStep, "1", DefaultValueConstant.CHECK_CAR_SOURCE_IN);//退票
                    break;
            }

            return true;
        } catch (Exception e) {
            logger.error("系统异常。", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }
    }

    //意向订单退订/订单退订/发票退订审批通过后新增处理
    private void changeStatusAfterWithdrawApproved(报价单表Model model报价单表, PushApprovalWorkFlowModel flow) {
        // 找到当前用户的索引
        String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();//报价编号
        // 20170123 新添加还原点处理 --bydf
        model报价单表.set是否还原点("是");
        model报价单表.set还原点创建时间(Timestamp.valueOf(LocalDateTime.now()));

        //1、顾客记录汇总.新车销售状态=8,
        repository顾客记录汇总.updteNewCarStatusById(model报价单表.get顾客编号(), 8);

        顾客记录汇总Model countUser = null;
        if (null != model报价单表 && null != model报价单表.get顾客编号()) {
            countUser = 顾客记录汇总Repository.findCusByCustomerID(model报价单表.get顾客编号());
        }
        String id = repository顾客进店记录表.findBJBH(quotedPriceCodeOrVin);
        顾客进店记录表Model model顾客进店记录表 = null;
        // 根据报价编号查找进店记录
        if (id != null && !id.trim().equals("")) {
            model顾客进店记录表 = repository顾客进店记录表.findOneByQuotedPriceCode(Integer.valueOf(id));
        }
        if (null != model顾客进店记录表 && !"退订".equals(model顾客进店记录表.get到店目的())) {

            if (model顾客进店记录表!=null&&"是".equals(model顾客进店记录表.get是否订单())) {//当天意向 订单改为0
                TrafficLogUtils.updateTrafficLogModel(model顾客进店记录表, 10);
            } else {//隔天意向订单改为-1

                TrafficLogUtils.updateTrafficLogModel(model顾客进店记录表, 11);
            }
            repository顾客进店记录表.save(model顾客进店记录表);

            updateUserOrder(model报价单表, "退订");

        } else if (null == model顾客进店记录表) { //没有进店记录则新增
            String re = saveStroe(model报价单表, countUser, "退订", "E:六个月以上订单");
            if (!"true".equals(re)) {
                logger.error("新增进店记录异常");
            }
            updateUserOrder(model报价单表, "退订");
        }



        //2.lsh金融申请.状态=12; 报价单表.初始报价单号=lsh金融申请.初始报价单号
        Lsh金融申请Model model金融申请表 = lsh金融申请表Repository.getApplyFinanceModelByIds(model报价单表.get初始报价单号());
        if (model金融申请表 != null) {
            lsh金融申请表Repository.updateFinByQuote("12", model金融申请表.get初始报价单号());
            //3.finance_log新增一条log数据
            FinanceLogModel fm = new FinanceLogModel();
            fm.setOrgQsn(model报价单表.get初始报价单号());
            fm.setState("12");
            fm.setLogUser(flow.getUserName());
            fm.setLogTime(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
            financeLogRepository.save(fm);
        }

        //4.lsh保险申请附属.状态=08;报价单表.初始报价单号=lsh保险申请附属.初始报价单号
        Lsh保险申请附属Model model保险申请附属 = lsh保险申请附属Repository.findInsByQuote(model报价单表.get初始报价单号());
        if (model保险申请附属 != null) {
            lsh保险申请附属Repository.updateStatusByQuote(model保险申请附属.get初始报价单号(), "08");
            //5.insurance_log新增一条log数据
            InsuranceLogModel im = new InsuranceLogModel();
            im.setState("08");
            im.setOrgQsn(model报价单表.get初始报价单号());
            im.setLogTime(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
            im.setLogUser(flow.getUserName());
        }
    }

    //订单/意向订单/合同/合同修改/换票通过后新增处理
    private void changeStatusAfterApproved(报价单表Model model报价单表, PushApprovalWorkFlowModel flow) {
        //1.lsh金融申请.状态=12; 报价单表.初始报价单号=lsh金融申请.初始报价单号
        Lsh金融申请Model model金融申请表 = lsh金融申请表Repository.getApplyFinanceModelByIds(model报价单表.get初始报价单号());
        if (model金融申请表 != null) {
            if ("02".equals(model金融申请表.get状态())) {
                lsh金融申请表Repository.updateFinByQuote("05", model金融申请表.get初始报价单号());
                //2.finance_log新增一条log数据
                FinanceLogModel fm = new FinanceLogModel();
                fm.setOrgQsn(model报价单表.get初始报价单号());
                fm.setState("05");
                fm.setLogUser(flow.getUserName());
                fm.setLogTime(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
                financeLogRepository.save(fm);
            }
        }

        //3.lsh保险申请附属.状态=08;报价单表.初始报价单号=lsh保险申请附属.初始报价单号
        Lsh保险申请附属Model model保险申请附属 = lsh保险申请附属Repository.findInsByQuote(model报价单表.get初始报价单号());
        if (model保险申请附属 != null) {
            if ("02".equals(model保险申请附属.get状态())) {
                lsh保险申请附属Repository.updateStatusByQuote(model保险申请附属.get初始报价单号(), "05");
                //4.insurance_log新增一条log数据
                InsuranceLogModel im = new InsuranceLogModel();
                im.setState("05");
                im.setOrgQsn(model报价单表.get初始报价单号());
                im.setLogTime(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
                im.setLogUser(flow.getUserName());
            }
        }
    }

    /**
     * 换车，库存表：老的（车辆零售状态-未卖，报价单号-null），新的（车辆零售状态-已卖，更新报价单号）
     * 根据报价编号查询初始报价编号，然后根据初始报价编号查询是否还原点=是的数据（即老的报价编号）
     *
     * @param model报价单表
     */
    private void doChangeCarStatus(报价单表Model model报价单表) {
        //根据报价编号查询初始报价编号，然后根据初始报价编号查询是否还原点=是的数据（即老的报价编号）
        if (model报价单表.get初始报价单号() != null) {
            List<报价单表Model> model报价单表OldList = repository报价单表.getListByInitQuoteNumberAnd是否还原点(model报价单表.get初始报价单号());
            //判断是否有换车，找到还原点=是的报价单表的库存编号，与当前的库存编号是否一致
            if (model报价单表OldList.size() > 0) {
                报价单表Model model报价单表Old = model报价单表OldList.get(0);
                //意向订单没有库存编号
                if (!model报价单表.get库存编号().equals(model报价单表Old.get库存编号())) {
                    //意向订单无库存编号
                    if (model报价单表Old.get库存编号() != null) {
                        Lsh库存表Model lsh库存表old = lsh库存表Repository.findOne(model报价单表Old.get库存编号());
                        lsh库存表old.set车辆零售状态("未卖");
                        lsh库存表old.set报价编号(null);
                        lsh库存表Repository.save(lsh库存表old);
                    }
                }
            }
        }
    }

    // 订单审批后处理
    private void postOrderProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus)
            throws Exception {
        // 取出当前用户审批条目
        PushApprovalWorkFlowModel flow = list.get(getCurrentStep(list, current_step));
        if ("1".equals(approvalStatus)) {
            //1、更新报价订单表的订单号-Dlr代码+年月日（6位）+生产号（10位或者11位）
            String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();

            报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
            if (model报价单表 == null) {
                logger.error("报价单表为空！报价编号:" + quotedPriceCodeOrVin);
            }
            顾客记录汇总Model model汇总 = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
            //1.5 更新报价单表：是否还原点：是；还原点时间nowtime
            Timestamp tsTime = Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            model报价单表.set是否还原点("是");
            model报价单表.set还原点创建时间(tsTime);
            报价单表Model maxValueModelIds = repository报价单表.save(model报价单表);

            if (model报价单表.get订单编号() == null) {
                logger.error("此报价单表无订单编号！报价编号：" + quotedPriceCodeOrVin);
            }
            报价订单表Model model报价订单表 = repository报价订单表.findOne(model报价单表.get订单编号());
            if (model报价订单表 == null) {
                logger.error("报价订单表为空！订单编号：" + model报价单表.get订单编号());
            }
            if (model报价单表.get库存编号() == null) {
                logger.error("此报价单表无库存编号！报价编号：" + quotedPriceCodeOrVin);
            }
            Lsh库存表Model lsh库存表Model = lsh库存表Repository.findOne(model报价单表.get库存编号());
            if (lsh库存表Model == null) {
                logger.error("库存表为空！库存编号：" + model报价单表.get库存编号());
            }
            String timeStr = new SimpleDateFormat("yyMMdd").format(new Date());
            if (lsh库存表Model.get生产号() == null) {
                logger.error("此库存的生产号为空，库存编号：" + lsh库存表Model.get库存编号());
            }


            String orderNum = flow.getPermit() + timeStr + lsh库存表Model.get生产号();
            model报价订单表.set订单号(orderNum);
            model报价订单表.set订单状态("订单C");
            model报价订单表.set更新时间(tsTime);
            java.sql.Date dt = new java.sql.Date(DateFormatUtils.getFormatDate("yyyy-MM-dd", new Date()).getTime());
            model报价订单表.set订单审批通过日期(tsTime);
            model报价订单表.set订单签署日期(dt);
            repository报价订单表.save(model报价订单表);//更新报价订单表:修改订单号和订单状态

            // 2、如是当天的订单，更新顾客进店记录表：到店目的-订单，是否订单-是
            String nowDay = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
            // 根据报价编号查找进店记录
            Integer validQuotedPriceCode = pushApprovalWorkFlowRepository.getValidQuotedPriceCode(Integer.parseInt(quotedPriceCodeOrVin));
            顾客进店记录表Model model顾客进店记录表 = repository顾客进店记录表.findOneByQuotedPriceCode(validQuotedPriceCode);
            if (model顾客进店记录表 == null) {
                logger.error("改顾客没有进店记录！报价编号:" + quotedPriceCodeOrVin);
            }
            if (model报价订单表.get订单申请日期() == null) {
                logger.error("报价订单表的订单申请日期为空！订单编号：" + model报价订单表.get订单编号());
                // 合同审批里面订单申请日期为空，赋值为当天
                model报价订单表.set订单申请日期(java.sql.Date.valueOf(LocalDate.now()));
            }
            //第一天订单申请审批，第二天有进店记录车资确认防止新增进店记录
            if (null != model顾客进店记录表&&(model顾客进店记录表.get进店日期().equals(DateFormatUtils.getFormatDate("yyyy-MM-dd",new Date())))) {
                // 更新顾客进店记录表
                /*model顾客进店记录表.set到店目的("订单");
                model顾客进店记录表.set是否订单("是");
                model顾客进店记录表.set是否报价("是");
                model顾客进店记录表.set客户级别("无评级:已经订单或交车");*/
                TrafficLogUtils.updateTrafficLogModel(model顾客进店记录表,1);//修改顾客进店表状态
                repository顾客进店记录表.save(model顾客进店记录表);
            } else {
                if (model顾客进店记录表 != null) {
                    //3、如不是当天的订单，顾客进店记录表新增3:00-3:01的进店记录
                    //克隆原记录
                    顾客进店记录表Model new顾客进店记录表 = (顾客进店记录表Model) CloneUtils.deepClone(model顾客进店记录表);
                    /*new顾客进店记录表.set客户级别("无评级:已经订单或交车");
                    new顾客进店记录表.set进店编号(null);
                    new顾客进店记录表.set是否来电("否");
                    new顾客进店记录表.set是否留档("是");
                    new顾客进店记录表.set是否新留档("否");
                    new顾客进店记录表.set是否首次到店("否");
                    new顾客进店记录表.set是否预约("否");
                    new顾客进店记录表.set到店时间(Time.valueOf(LocalTime.of(3, 0, 0)));
                    new顾客进店记录表.set离店时间(Time.valueOf(LocalTime.of(3, 1, 0)));
                    new顾客进店记录表.set停留时间(1);
                    new顾客进店记录表.set到店目的("订单");
                    new顾客进店记录表.set是否订单("是");
                    // 黄永平增加 进店日期，飞哥给的方法 2016.12.24
                    new顾客进店记录表.set进店日期(java.sql.Date.valueOf(LocalDate.now()));*/
                    TrafficLogUtils.updateTrafficLogModel(new顾客进店记录表,2);//修改顾客进店表状态
                    repository顾客进店记录表.save(new顾客进店记录表);
                } else {
                    //未进店用户订单补入进店记录
                    saveStroe(model报价单表, model汇总, "订单","无评级:已经订单或交车");
                }
            }
            // 4、顾客订单记录新增一条数据
            // 路松
            //修改原因:顾客订单记录.订单编号 <> 报价订单表.订单编号
            //原有程序 将这两个 订单编号 混在一起，导致 顾客订单记录 表数据出错
            //现修改： 逻辑 -- 顾客编号、库存编号在 顾客订单记录 表中确定唯一 信息记录，有则修改，无则新增
            顾客订单记录Model md = null;
            List<顾客订单记录Model> 顾客订单记录Models = repository顾客订单记录.findOrderByCustIdAndSrockId(model报价单表.get顾客编号(), model报价单表.get库存编号());
            if (顾客订单记录Models != null && !顾客订单记录Models.isEmpty()) {
                md = 顾客订单记录Models.get(0);
            } else {
                md = new 顾客订单记录Model();
            }
//            顾客订单记录Model md = new 顾客订单记录Model();
//            md.set订单编号(model报价订单表.get订单编号());
            md.set许可(model报价单表.get许可());
            if (model报价单表.get顾客编号() == null) {
                logger.error("报价单表无顾客编号！报价编号：" + model报价单表.get报价编号());
            }
            md.set顾客编号(model报价单表.get顾客编号());
            if (model报价单表.get车型编号() == null) {
                logger.error("报价单表无车型编号！车型编号：" + model报价单表.get报价编号());
            }
            md.set车型(model报价单表.get车型编号());
            if (model顾客进店记录表 != null) {
                if (model顾客进店记录表.get销售顾问() == null) {
                    logger.error("顾客进店记录表没有销售顾问！进店编号：" + model顾客进店记录表.get进店编号());
                }
                md.set销售顾问(model顾客进店记录表.get销售顾问());
            }
            if (model报价订单表.get订单签署日期() == null) {
                logger.error("订单签署日期为空！订单编号：" + model报价订单表.get订单编号());
            }
            md.set订单日期(model报价订单表.get订单签署日期());
            md.set库存编号(model报价单表.get库存编号());
            md.set状态("已订单");
            md.set销售顾问(model报价单表.get销售顾问());
            repository顾客订单记录.save(md);

            // 5、更新LSH库存表，车辆零售状态-已卖，更新报价单号
            lsh库存表Model.set车辆零售状态("已卖");
            lsh库存表Model.set报价编号(Integer.valueOf(flow.getQuotedPriceCodeOrVin()));
            lsh库存表Repository.save(lsh库存表Model);

            // 6、顾客记录汇总，是否订单-是，新顾客级别-无评级
            顾客记录汇总Model model顾客记录汇总 = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
            model顾客记录汇总.set是否订单("是");
            model顾客记录汇总.set新顾客级别("无评级:已经订单或交车");
            model顾客记录汇总.set顾客状态("已订单");
            model顾客记录汇总.set新车销售状态(13);
            repository顾客记录汇总.save(model顾客记录汇总);

            //修改保险金融状态和新增日志
            changeStatusAfterApproved(model报价单表, flow);
            //给财务发送消息 确认订金
            SendMsgRoleUtil.sendMsgToAllRole(model报价单表.get许可(), model顾客记录汇总.get所属销售顾问(), MessageType.Type.getName(MessageType.MSG_TYPE_FINANCE_SYS), MessageContext.getOrderApprovalAgreement(model顾客记录汇总.get顾客姓名(), model顾客记录汇总.get电话号码()), DefaultValueConstant.SYS_ROLE_FANCE, model顾客记录汇总.get电话号码());

            if ("是".equals(model报价订单表.get是否现定现交())) { // 如果是现订现交流程，订单审批通过后直接生成合同审批的流程
                PushApprovalWorkFlowModel mo = new PushApprovalWorkFlowModel();
                mo.setPermit(model报价单表.get许可());
                mo.setType(ApprovalUtils.CONTRACT);
                mo.setQuotedPriceCodeOrVin(model报价单表.get报价编号() + "");
                ResultData resultData = this.addApprovalWorkFlow(mo, model报价单表.get销售顾问()); // 因为接口问题，不能正常返回ResultData
                logger.info("现代现交流程订单审批通过，直接新建合同审批流程，resultData=" + JsonObjectUtils.writeAsJson(resultData));
                logger.info("现代现交流程订单审批通过，直接新建合同审批流程，许可：" + model报价单表.get许可() + "，报价编号为：" + model报价单表.get报价编号());
                model报价订单表.set订单状态("合同O");
                model报价订单表.set订金类型("订金");
                model报价订单表.set订金金额(model报价单表.get折后价());
                model报价订单表.set预计开票日期(java.sql.Date.valueOf(LocalDate.now()));
                repository报价订单表.save(model报价订单表);
            }
        } else if ("2".equals(approvalStatus)) {
            //拒绝时，库存表状态改为未卖
            String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();//报价编号
            报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
            Lsh库存表Model lsh库存表Model = lsh库存表Repository.findOne(model报价单表.get库存编号());
            lsh库存表Model.set车辆零售状态("未卖");
            lsh库存表Repository.save(lsh库存表Model);
            顾客记录汇总Model model顾客记录汇总 = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
            if (StringUtils.isNullOrBlank(model顾客记录汇总.get顾客姓名())) {
                model顾客记录汇总.set顾客姓名("无");
            }
            if (StringUtils.isNullOrBlank(model顾客记录汇总.get电话号码())) {
                model顾客记录汇总.set电话号码("无");
            }
            //订单状态改为null, removed By tony
            //repository报价订单表.updateOrderStatusById(model报价单表.get订单编号(), null);

            //订单状态改为订单驳回(订单R)
            repository报价订单表.updateOrderStatusById(model报价单表.get订单编号(), "订单R");

            //回滚数据
            rollBackOrderData(model报价单表);

            String content = "您提交的生产号为" + lsh库存表Model.get生产号() + "的车辆的订单审批已被驳回，客户姓名：" +
                    model顾客记录汇总.get顾客姓名() + "，客户电话：" + model顾客记录汇总.get电话号码() + ",原因" + flow.getRemark();
            LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), model报价单表.get销售顾问(), "订单",
                    content, flow.getUserName(), model顾客记录汇总.get电话号码());
            List appList = new ArrayList();
            appList.add(model报价单表.get销售顾问());
            JPush.sendPushForAndroidAndIos(content, content,
                    JsonObjectUtils.getJsonObject(flow.getType().toString(), "2", quotedPriceCodeOrVin, "",
                            "", model报价单表.get销售顾问()),
                    appList, JPush.Platforms.iTask);
        }
    }

    // 对  后市场的 变化 需要 进行 相应的 修改
    @Transactional
    private void getLastMsgToUpdateStatus(String quotedPriceCodeOrVin, 报价单表Model maxValueModelIds, PushApprovalWorkFlowModel flow) {
        // 首先 根据 报价编号 查查 上一次 有没有 精品  这一次有没有 精品
        int nowbianhaosx = Integer.parseInt(quotedPriceCodeOrVin);
        //这个就是 判断  现在这一次有没有 精品
        List nowpjlist2 = pushApprovalWorkFlowRepository.findValueModelListis(nowbianhaosx);
        // 这个可以报价编号 ,b.精品   把 报价编号和 精品 都 判断
        List listlastone = pushApprovalWorkFlowRepository.findLastBianhaoDetail(nowbianhaosx);
        List listlastoneBianhao = pushApprovalWorkFlowRepository.findLastBianhao(nowbianhaosx);

        boolean preFound = false, nowFound = false;
        if (nowpjlist2 != null && nowpjlist2.size() > 0) {
            Map mos1 = (Map) nowpjlist2.get(0);
            nowFound = !"".equals(mos1.get("精品编号")) && mos1.get("精品编号") != null;
        }

        if (!(listlastoneBianhao == null || listlastoneBianhao.isEmpty())) {
            if (listlastone != null && listlastone.size() > 0) {
                Map lastProduction = (Map) listlastone.get(0);
                preFound = !"".equals(lastProduction.get("精品")) && lastProduction.get("精品") != null;
            }
        }

        // 上一次 确实没有
        if (!preFound && nowFound) {
            logger.warn("后市场精品修改，上一次没有这一次有的情况,这次报价编号:{}",nowbianhaosx);
            updateNowlist(nowbianhaosx, flow);// 这一次有 精品，那么我们开始 一个一个的 插入
        } else if (preFound && nowFound) {
            Map moslLast = (Map) listlastoneBianhao.get(0);
            int lastbianhao = Integer.parseInt(moslLast.get("报价编号").toString());
            logger.warn("后市场精品修改，上一次有这一次也有的情况,上次报价编号：{}，这次报价编号：{}",lastbianhao,nowbianhaosx);
            allfor(nowbianhaosx, lastbianhao, flow);
        } else if (preFound && !nowFound) {
            Map moslLast = (Map) listlastoneBianhao.get(0);
            int lastbianhao = Integer.parseInt(moslLast.get("报价编号").toString());
            logger.warn("后市场精品修改,上一次有这一次没有的情况，上次报价编号：{}，这次报价编号：{}",lastbianhao,nowbianhaosx);
            updateLastList(nowbianhaosx, listlastone, flow);
        }
    }


    private void allfor(int nowbianhaosx, int lastbianhao, PushApprovalWorkFlowModel flow) {
        List s1 = pushApprovalWorkFlowRepository.findValueModelList(nowbianhaosx);
        List s2 = pushApprovalWorkFlowRepository.findValueModelList(lastbianhao);
        Map sm1 = new HashMap();
        Map sm2 = new HashMap();
        List<Map> commonMap = new ArrayList<>();
        List<Map> deleteMap = new ArrayList<>();
        List<Map> addMap = new ArrayList<>();
        int i = 0;
        int j = 0;
        String s = null;
        a:
        for (i = 0; i < s1.size(); i++) {
            sm1 = (Map) s1.get(i);
            int sm1product = Integer.parseInt(sm1.get("productId").toString());
            int sm1comid = Integer.parseInt(sm1.get("comboId").toString());
            int sm1id = Integer.parseInt(sm1.get("编号").toString());
            int sm1sum = Integer.parseInt(sm1.get("数量").toString());
            String sm1price = "";
            if (sm1.get("折后价") != null) {
                sm1price = sm1.get("折后价").toString();
            } else {
                logger.warn("no price info for comboId={}, productId={}", sm1comid, sm1product);
            }

            for (j = 0; j < s2.size(); j++) {
                sm2 = (Map) s2.get(j);
                int sm2product = Integer.parseInt(sm2.get("productId").toString());
                int sm2comid = Integer.parseInt(sm2.get("comboId").toString());
                int sm2id = Integer.parseInt(sm2.get("编号").toString());
                int sm2sum = Integer.parseInt(sm2.get("数量").toString());
                String sm2price = "";
                if (sm2.get("折后价") != null) {
                    sm2price = sm2.get("折后价").toString();
                } else {
                    logger.warn("no price info for comboId={}, productId={}", sm2comid, sm2product);
                }

                if (sm1product == sm2product && sm1comid == sm2comid) {
                    commonMap.add(sm1);
                    //System.out.println(s1[i] + "标记为相同");
                    List<报价精品详细表精品Model> youmeiyoulist =
                            repository报价精品详细精品表.findByThree(sm2product, sm2comid, sm2id);
                    if (youmeiyoulist != null && youmeiyoulist.size() > 0) {
                        if (sm2sum == sm1sum && sm2price.equals(sm1price)) {
                            int ids = youmeiyoulist.get(0).getId();
                            报价精品详细表精品Model mlist1 = repository报价精品详细精品表.findOne(ids);
                            mlist1.set编号(sm1id);
                            // mlist1.set备注("正向 ：当 上一次已经插入且+没有 修改 数量 和折后价 +这次更新+编号 状态不变");
                            logger.warn("精品信息修改，上一次报价编号：{},下一次报价编号：{},更新的数据为：{}",lastbianhao,nowbianhaosx, JSON.toJSONString(mlist1));
                            repository报价精品详细精品表.save(mlist1);
                        } else {
                            int idss2 = youmeiyoulist.get(0).getId();
                            报价精品详细表精品Model mlists2 = repository报价精品详细精品表.findOne(idss2);
                            mlists2.set编号(sm1id);
                            mlists2.set数量(sm1sum);
                            mlists2.setOrderStatus("5");
                            //  mlists2.set备注("正向 ： 当 上一次已经插入且+有 修改 数量 和折后价 +这次更新+编号+ 状态5 ");
                            repository报价精品详细精品表.save(mlists2);
                            saveMsgByXiaoshouGuwenToAllJpzhuanyuan(nowbianhaosx, flow);
                            logger.warn("精品信息修改，上一次报价编号：{},下一次报价编号：{},更新的数据为：{}",lastbianhao,nowbianhaosx, JSON.toJSONString(mlists2));
                        }

                    } else {

                        if (sm2sum == sm1sum && sm2price.equals(sm1price)) {
                            报价精品详细表精品Model mlist3a = new 报价精品详细表精品Model();
                            mlist3a.setOrderStatus("1");
                            mlist3a.set数量(sm1sum);
                            mlist3a.set编号(sm1id);
                            mlist3a.setComboId(sm1comid);
                            mlist3a.setProductId(sm1product);
                            //mlist3a.set备注("正向 ：当 上一次没插入且+没有 修改 数量 和折后价 +这次更新+编号 状态1");
                            repository报价精品详细精品表.save(mlist3a);
                            logger.warn("精品信息修改，上一次报价编号：{},下一次报价编号：{},插入的数据为：{}",lastbianhao,nowbianhaosx, JSON.toJSONString(mlist3a));
                        } else {
                            报价精品详细表精品Model mlist3a = new 报价精品详细表精品Model();
                            mlist3a.setOrderStatus("5");
                            mlist3a.set数量(sm1sum);
                            mlist3a.set编号(sm1id);
                            mlist3a.setComboId(sm1comid);
                            mlist3a.setProductId(sm1product);
                            // mlist3a.set备注("正向 ：当 上一次没插入且+ 这一次 修改 数量 和折后价 +这次插入 +编号 状态5");
                            repository报价精品详细精品表.save(mlist3a);
                            logger.warn("精品信息修改，上一次报价编号：{},下一次报价编号：{},插入的数据为：{}",lastbianhao,nowbianhaosx, JSON.toJSONString(mlist3a));
                            saveMsgByXiaoshouGuwenToAllJpzhuanyuan(nowbianhaosx, flow);
                        }


                    }

                    continue a;
                }
            }
            if (s2 != null && j == s2.size()) {
                addMap.add(sm1);
                // System.out.println(s1[i] + "标记为新增");
                报价精品详细表精品Model mlist3as = new 报价精品详细表精品Model();
                mlist3as.setOrderStatus("1");
                mlist3as.set数量(sm1sum);
                mlist3as.set编号(sm1id);
                mlist3as.setComboId(sm1comid);
                mlist3as.setProductId(sm1product);
                // mlist3as.set备注("正向 ：当 上一次压根就 没有 这个精品   这一次插入 ");
                repository报价精品详细精品表.save(mlist3as);
                saveMsgByXiaoshouGuwenToAllJpzhuanyuan(nowbianhaosx, flow);
            }
        }

        List s3 = pushApprovalWorkFlowRepository.findValueModelList(nowbianhaosx);
        int newbianhao = 0;
        if (s3 != null && s3.size() > 0) {
            Map bianhaom = (Map) s3.get(0);
            String bianhaoms = bianhaom.get("精品").toString();
            newbianhao = Integer.parseInt(bianhaoms);
        }

        List s4 = pushApprovalWorkFlowRepository.findValueModelList(lastbianhao);
        Map sm3 = new HashMap();
        Map sm4 = new HashMap();

        int ij = 0;
        int jj = 0;
        b:
        for (ij = 0; ij < s4.size(); ij++) {
            sm4 = (Map) s4.get(ij);
            int sm4product = Integer.parseInt(sm4.get("productId").toString());
            int sm4comid = Integer.parseInt(sm4.get("comboId").toString());
            int sm4id = Integer.parseInt(sm4.get("编号").toString());
            int sm4sum = Integer.parseInt(sm4.get("数量").toString());
            for (jj = 0; jj < s3.size(); jj++) {
                sm3 = (Map) s3.get(jj);
                int sm3product = Integer.parseInt(sm3.get("productId").toString());
                int sm3comid = Integer.parseInt(sm3.get("comboId").toString());
                if (sm4product == sm3product && sm3comid == sm4comid) {
                    commonMap.add(sm4);
                    //System.out.println(s1[i] + "标记为相同");
                    continue b;
                }
            }
            if (s3 != null && jj == s3.size()) {
                deleteMap.add(sm4);
                //System.out.println(s2[i] + "标记为删除");
                List<报价精品详细表精品Model> youmeiyoulists = repository报价精品详细精品表.findByThree(sm4product, sm4comid, sm4id);
                if (youmeiyoulists != null && youmeiyoulists.size() > 0) {
                    int ids1 = youmeiyoulists.get(0).getId();
                    报价精品详细表精品Model mlist7 = repository报价精品详细精品表.findOne(ids1);
                    mlist7.set编号(newbianhao);
                    mlist7.setOrderStatus("9");
                    //  mlist7.set备注("反向：这是 上一次 已经插入了+ 所以 现在只更新 +改编号，+ 状态 9 ");
                    repository报价精品详细精品表.save(mlist7);
                    logger.warn("精品信息修改，上一次报价编号：{},下一次报价编号：{},更新的数据为：{}",lastbianhao,nowbianhaosx, JSON.toJSONString(mlist7));
                    saveMsgByXiaoshouGuwenToAllJpzhuanyuan(nowbianhaosx, flow);
                } else {
                    报价精品详细表精品Model mlist3as = new 报价精品详细表精品Model();
                    mlist3as.set编号(newbianhao);
                    mlist3as.setOrderStatus("9");
                    mlist3as.setComboId(sm4comid);
                    mlist3as.setProductId(sm4product);
                    mlist3as.set数量(sm4sum);
                    // mlist3as.set备注("反向： 这是 上一次 没有插入了+ 所以 现在插入 +现在的编号+ 以前的 conid + productId，筛选出 已经删除了的+ 状态 9 ");
                    repository报价精品详细精品表.save(mlist3as);
                    logger.warn("精品信息修改，上一次报价编号：{},下一次报价编号：{},插入的数据为：{}",lastbianhao,nowbianhaosx, JSON.toJSONString(mlist3as));

                }
            }
        }
    }


    // 把上一次全部删除的 添加之后 状态 为 9
    private void updateLastList(int nowbianhaosx, List listlastone, PushApprovalWorkFlowModel flow) {

        Map mapLast = (Map) listlastone.get(0);
        String jpbianhao = mapLast.get("精品").toString();
        List lastListmodel = pushApprovalWorkFlowRepository.findLastModelListis(jpbianhao);
        Map pjMap1 = new HashMap();
        for (int ij = 0; ij < lastListmodel.size(); ij++) {
            报价精品详细表精品Model valueModelone = new 报价精品详细表精品Model();
            pjMap1 = (Map) lastListmodel.get(ij);
            if (StringUtils.isNullOrBlank(pjMap1.get("productId"))) {
                continue;
            }
            int p1m = Integer.parseInt(pjMap1.get("productId").toString());
            int p2m = Integer.parseInt(pjMap1.get("编号").toString());
            int p3m = Integer.parseInt(pjMap1.get("comboId").toString());
            int p4m = Integer.parseInt(pjMap1.get("数量").toString());
            // 开始赋值
            valueModelone.setComboId(p3m);
            valueModelone.setProductId(p1m);
            valueModelone.set数量(p4m);
            valueModelone.set编号(p2m);
            valueModelone.setOrderStatus("9");// 以前是没有的 就是  1---对应的 未订单
            // valueModelone.set备注("这是测试的上一次把 东西全删除了--  xxd");
            repository报价精品详细精品表.save(valueModelone);


        }
        // 发送消息
        saveMsgByXiaoshouGuwenToAllJpzhuanyuan(nowbianhaosx, flow);

    }


    // 给一个 报价编号 插入 进去它 所有的 东西 已经确定 是有 东西
    @Transactional
    private void updateNowlist(int nowbianhaosx, PushApprovalWorkFlowModel flow) {
        List pjlist = pushApprovalWorkFlowRepository.findValueModelList(nowbianhaosx);
        Map pjMap1 = new HashMap();
        //报价精品详细表精品Model valueModelone=new 报价精品详细表精品Model();
        // 已经确保有 ， 那么 直接插入
        for (int ij = 0; ij < pjlist.size(); ij++) {
            报价精品详细表精品Model valueModelone = new 报价精品详细表精品Model();
            pjMap1 = (Map) pjlist.get(ij);
            int p1m = Integer.parseInt(pjMap1.get("productId").toString());
            int p2m = Integer.parseInt(pjMap1.get("编号").toString());
            int p3m = Integer.parseInt(pjMap1.get("comboId").toString());
            int p4m = Integer.parseInt(pjMap1.get("数量").toString());
            // 开始赋值
            valueModelone.setComboId(p3m);
            valueModelone.setProductId(p1m);
            valueModelone.set数量(p4m);
            valueModelone.set编号(p2m);
            valueModelone.setOrderStatus("1");// 以前是没有的 就是  1---对应的 未订单
            //  valueModelone.set备注("这是测试的xxd");
            repository报价精品详细精品表.save(valueModelone);
            // 发送消息
        }
        saveMsgByXiaoshouGuwenToAllJpzhuanyuan(nowbianhaosx, flow);
        return;

    }

    // 根据  报价编号 ---》 销售顾问（内容一部分）+许可-----拿到 用户表 所有的 精品专员（对应的 编号）（接受者）
    @Transactional
    private void saveMsgByXiaoshouGuwenToAllJpzhuanyuan(int nowbianhaox, PushApprovalWorkFlowModel flow) {
        // 拿到 销售顾问 的 用户名
        报价单表Model model = repository报价单表.findOne(nowbianhaox);
        顾客记录汇总Model customModel = 顾客记录汇总Repository.findOne(model.get顾客编号());
        String carMan="";
        if(customModel!=null){
            carMan=customModel.get顾客姓名();
        }
        String carStyle="";
        String carVin="";
        if(model!=null&&model.get库存编号()!=null){
            Lsh库存表Model carmodels=  lsh库存表Repository.findOne(model.get库存编号());
            if(carmodels!=null){
                carVin=carmodels.get车架号();
                if(carmodels.get车型编号()!=null){
                    Lsh车型Model onetem=lsh车型Repository.findOne(carmodels.get车型编号());
                    if(onetem!=null){
                        if(!Strings.isNullOrEmpty(onetem.get车型详细())){
                            carStyle=onetem.get车型详细();
                        }
                    }
                }

            }
        }
        // 发送人
        String postman = model.get销售顾问();
        String postManName=postman;
        用户Model onitemss= repository用户.findBy许可And用户名(model.get许可(),postman);
        if(onitemss!=null){
            postManName=onitemss.get人员姓名();
        }

        String xuke = model.get许可();
        // 接收人
        List<用户Model> molist = repository用户.findAlljpzhuanyuan(xuke);
        for (int ids = 0; ids < molist.size(); ids++) {
            用户Model molsint = molist.get(ids);
            String content = " 车主: "+carMan+" , 车型: " +
                    carStyle+", 车架号: "+carVin+" ,销售顾问: "+postManName+ " 后市场订单已修改，请查看。";
            // 发送人                   接收人                                      更新账号
            LshMsgUtils.getLshMsg(flow.getPermit(), postman, flow.getPermit(), molsint.get用户名(), "后市场", content, flow.getUserName(), customModel.get电话号码());
        }
        return;

    }


    //意向订单后续处理
    @Transactional
    private void postIntentOrderProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus) throws Exception {
        int i = getCurrentStep(list, current_step);
        PushApprovalWorkFlowModel flow = list.get(i);
        String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();//报价编号
        报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
        if (model报价单表 == null) {
            logger.error("报价单表为空！报价编号:" + quotedPriceCodeOrVin);

            return;
        }
        if (model报价单表.get订单编号() == null) {
            logger.error("订单编号为空！报价编号:" + quotedPriceCodeOrVin);

            return;
        }

        报价订单表Model model报价订单表 = repository报价订单表.findOne(model报价单表.get订单编号());
        if (model报价订单表 == null) {
            logger.error("报价订单表为空！报价编号:" + quotedPriceCodeOrVin);

            return;
        }

        //审批通过:报价订单表：订单状态=意向订单C
        if ("1".equals(approvalStatus)) {
            model报价订单表.set订单审批通过日期(Timestamp.valueOf(LocalDateTime.now()));
            model报价订单表.set订单状态("意向订单C");
            repository报价订单表.save(model报价订单表);
            //顾客记录汇总：新车销售状态=12
            repository顾客记录汇总.updteNewCarStatusById(model报价单表.get顾客编号(), 12);
            //设置还原点
//            repository报价单表.set还原点AndTime(model报价单表.get报价编号(), "是", DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
            model报价单表.set是否还原点("是");
            model报价单表.set还原点创建时间(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
            // 20161201 意向订单审批通过后，往库存表中添加虚拟车
            virtualStockModelRepository.setNewVirtualStockCode();   // 虚拟车id + 1
            Integer virtualId = virtualStockModelRepository.getVirtualStockCode();
            String virtualVin = String.format("IRISTechnologies%08d", virtualId);
            Lsh库存表Model lsh库存表Model = new Lsh库存表Model();
            lsh库存表Model.set车型编号(model报价单表.get车型编号());
            lsh库存表Model.set生产号(virtualVin);
            lsh库存表Model.set车架号(virtualVin);
            lsh库存表Model.set颜色(model报价单表.get外观());
            lsh库存表Model.set内饰(model报价单表.get内饰());
            lsh库存表Model.set加配配置(null);
            lsh库存表Model.set加配价格含税(null);
            lsh库存表Model.set标配Msrp含税(model报价单表.get原价());
            //BUG5432 【来源售后】【APP】IMGT端车辆MSRP价格显示异常  已经解决
            lsh库存表Model.set实际Msrp含税(model报价单表.get原价());
            lsh库存表Model.set车辆零售状态("未卖");
            lsh库存表Model.set所属经销商(model报价单表.get许可());
            lsh库存表Model.setIsDelete((byte) 0);
            lsh库存表Model.set报价编号(model报价单表.get报价编号());
            lsh库存表Repository.save(lsh库存表Model);
            // 将报价单表的库存编号更新为新建的虚拟库存编号
            model报价单表.set库存编号(lsh库存表Model.get库存编号());
            //修改保险金融状态和新增日志
            changeStatusAfterApproved(model报价单表, flow);
            //给财务发送消息 确认订金
            顾客记录汇总Model model顾客记录汇总 = repository顾客记录汇总.findOne(model报价单表.get顾客编号());

            // 根据报价编号查找进店记录
            Integer validQuotedPriceCode = pushApprovalWorkFlowRepository.getValidQuotedPriceCode(Integer.parseInt(quotedPriceCodeOrVin));
            顾客进店记录表Model model顾客进店记录表 = repository顾客进店记录表.findOneByQuotedPriceCode(validQuotedPriceCode);
            if (model顾客进店记录表 == null) {
                logger.error("改顾客没有进店记录！报价编号:" + quotedPriceCodeOrVin);
            }
            if (model报价订单表.get订单申请日期() == null) {
                logger.error("报价订单表的订单申请日期为空！订单编号：" + model报价订单表.get订单编号());
                // 合同审批里面订单申请日期为空，赋值为当天
                model报价订单表.set订单申请日期(java.sql.Date.valueOf(LocalDate.now()));
            }
            //第一天订单申请审批，第二天有进店记录车资确认防止新增进店记录
            if (null != model顾客进店记录表&&(model顾客进店记录表.get进店日期().equals(DateFormatUtils.getFormatDate("yyyy-MM-dd",new Date())))) {
                TrafficLogUtils.updateTrafficLogModel(model顾客进店记录表,12);//修改顾客进店表状态
                repository顾客进店记录表.save(model顾客进店记录表);
            } else {
                if (model顾客进店记录表 != null) {
                    //3、如不是当天的订单，顾客进店记录表新增3:00-3:01的进店记录
                    //克隆原记录
                    顾客进店记录表Model new顾客进店记录表 = (顾客进店记录表Model) CloneUtils.deepClone(model顾客进店记录表);
                    TrafficLogUtils.updateTrafficLogModel(new顾客进店记录表,13);//修改顾客进店表状态
                    repository顾客进店记录表.save(new顾客进店记录表);
                } else {
                    //未进店用户订单补入进店记录

                    saveStroe2(model报价单表, model顾客记录汇总, "订单","无评级:已经订单或交车");
                }
            }


            SendMsgRoleUtil.sendMsgToAllRole(model报价单表.get许可(), model顾客记录汇总.get所属销售顾问(), MessageType.Type.getName(MessageType.MSG_TYPE_FINANCE_SYS), MessageContext.getPurposeApprovalAgreement(model顾客记录汇总.get顾客姓名(), model顾客记录汇总.get电话号码()), DefaultValueConstant.SYS_ROLE_FANCE, model顾客记录汇总.get电话号码());
        } else if ("2".equals(approvalStatus)) {
            //Removed by Tony
            //repository报价订单表.updateOrderStatusById(model报价单表.get订单编号(), null);

            //订单状态改为订单驳回(订单R)
            repository报价订单表.updateOrderStatusById(model报价单表.get订单编号(), "意向订单R");

            顾客记录汇总Model model顾客记录汇总 = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
            if (StringUtils.isNullOrBlank(model顾客记录汇总.get顾客姓名())) {
                model顾客记录汇总.set顾客姓名("无");
            }
            if (StringUtils.isNullOrBlank(model顾客记录汇总.get电话号码())) {
                model顾客记录汇总.set电话号码("无");
            }
            //回滚数据
            rollBackOrderData(model报价单表);

            //发送消息
            String content = "您提交意向订单审批已被驳回，客户姓名：" +
                    model顾客记录汇总.get顾客姓名() + "，客户电话：" + model顾客记录汇总.get电话号码() + ",原因" + flow.getRemark();
            LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), model报价单表.get销售顾问(), "订单",
                    content, flow.getUserName(), model顾客记录汇总.get电话号码());
            List appList = new ArrayList();
            appList.add(model报价单表.get销售顾问());
            JPush.sendPushForAndroidAndIos(content, content,
                    JsonObjectUtils.getJsonObject(flow.getType().toString(), "2", quotedPriceCodeOrVin, "",
                            "", model报价单表.get销售顾问()),
                    appList, JPush.Platforms.iTask);
        }
    }

    // 合同审批后处理
    @Transactional
    private void postContractProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus, int entrance) throws Exception {
        报价单表Model 报价单表Model = repository报价单表.findOne(Integer.parseInt(list.get(0).getQuotedPriceCodeOrVin()));
        报价订单表Model 报价订单表Model = repository报价订单表.findOne(报价单表Model.get订单编号());
        // 现订现交的逻辑处理
        // 业务上若没有订单直接走合同，叫作“现订现交”
        // list报价编号对应的 报价订单表，若订单号为空，表示此流程在业务上是当天来当天交车
        // 设置 报价订单表 预计开票日期 = 当天    报价订单表 审批备注 = 现订现交
        // 调用 订单审批 后处理，补充订单数据
        PushApprovalWorkFlowModel flow = list.get(getCurrentStep(list, current_step));
        if ("1".equals(approvalStatus) || "3".equals(approvalStatus)) { // 通过处理
            if ("否".equals(报价订单表Model.get是否现定现交())) { // 非现订现交的特别处理
                String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();
                String nowDay = new SimpleDateFormat("yyyy-MM-dd").format(new Date());

                String id = repository顾客进店记录表.findBJBH(quotedPriceCodeOrVin);
                if(! (id == null || id.trim().equals(""))) {
                    顾客进店记录表Model model顾客进店记录表 = repository顾客进店记录表.findOneByQuotedPriceCode(Integer.valueOf(id));
                    if (model顾客进店记录表 == null || !nowDay.equals(new SimpleDateFormat("yyyy-MM-dd").format(model顾客进店记录表.get进店日期()))) {
                        logger.warn("改顾客没有今日进店记录！报价编号:" + id);
                    } else {
                        /*model顾客进店记录表.set到店目的("办手续");
                        model顾客进店记录表.set客户级别("无评级:已经订单或交车");*/
                        TrafficLogUtils.updateTrafficLogModel(model顾客进店记录表, 3);
                        repository顾客进店记录表.save(model顾客进店记录表);
                    }
                }else{
                    logger.warn("找不到进店编号！报价编号:" + quotedPriceCodeOrVin);
                }
            }

            //1、报价订单表：订单状态=合同C
            String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();//报价编号
            报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
            Timestamp ts = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
            repository报价单表.set还原点AndTime(model报价单表.get报价编号(), "是", ts);
            顾客记录汇总Model r = repository顾客记录汇总.findOne(报价单表Model.get顾客编号());
            if (StringUtils.isNullOrBlank(r.get顾客姓名())) {
                r.set顾客姓名("无");
            }
            if (StringUtils.isNullOrBlank(r.get电话号码())) {
                r.set电话号码("无");
            }
            Lsh车型Model lsh车型Model = lsh车型Repository.findOne(报价单表Model.get车型编号());

            if (model报价单表 == null) {
                logger.error("报价单表为空！报价编号:" + quotedPriceCodeOrVin);
            }
            if (model报价单表.get订单编号() == null) {
                logger.error("此报价单表无订单编号！报价编号：" + quotedPriceCodeOrVin);
            } else {
                报价订单表Model model报价订单表 = repository报价订单表.findOne(model报价单表.get订单编号());
                model报价订单表.set订单状态("合同C");
                repository报价订单表.save(model报价订单表);
            }

            //2、报价交车表：合同签约日期更新
            if (model报价单表.get交车() == null) {
                logger.error("此报价单表无交车！报价编号：" + quotedPriceCodeOrVin);
            } else {
                报价交车表Model model报价交车表 = repository报价交车表.findOne(model报价单表.get交车());
                model报价交车表.set合同签约日期(new java.sql.Date(DateFormatUtils.getFormatDate("yyyy-MM-dd HH:mm:ss", new Date()).getTime()));

                // 合同审批完成，生成合同编号
                // 合同编号计算
                String splitter = "__";
                String itemName = "合同个性化编号";
                Itask基础设置ModelPK iTaskMoPk = new Itask基础设置ModelPK();
                iTaskMoPk.set许可(model报价单表.get许可());
                iTaskMoPk.set设置项目(itemName);
                Itask基础设置Model iTaskMo = itask基础设置Repository.findOne(iTaskMoPk);
                if (iTaskMo == null) { // 没有数据，初始化
                    Itask基础设置Model newTaskMo = new Itask基础设置Model();
                    newTaskMo.set许可(model报价单表.get许可());
                    newTaskMo.set设置项目(itemName);
                    newTaskMo.set值(LocalDate.now().toString() + splitter + "001");
                    newTaskMo.set更新时间(Timestamp.valueOf(LocalDateTime.now()));
                    iTaskMo = itask基础设置Repository.save(newTaskMo);
                } else {
                    if (LocalDate.now().toString().equals(iTaskMo.get值().split(splitter)[0])) { // 如果还是当天的编号，编号+1，使用新编号
                        Integer newNum = Integer.parseInt(iTaskMo.get值().split(splitter)[1]) + 1;
                        String strNewNum;
                        if ((newNum + "").length() == 1) {
                            strNewNum = "00" + newNum;
                        } else if ((newNum + "").length() == 2) {
                            strNewNum = "0" + newNum;
                        } else {
                            strNewNum = newNum + "";
                        }
                        iTaskMo.set值(LocalDate.now().toString() + splitter + strNewNum);
                        iTaskMo.set更新时间(Timestamp.valueOf(LocalDateTime.now()));
                        iTaskMo = itask基础设置Repository.save(iTaskMo);
                    } else  {  // 不是的话，生成新的一天的起始数据
                        iTaskMo.set值(LocalDate.now().toString() + "__001");
                        itask基础设置Repository.save(iTaskMo);
                    }
                }
                // 合同编号生成
                String contractCode = "XSD" + model报价单表.get许可() + LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd")) + iTaskMo.get值().split(splitter)[1];
                model报价交车表.set合同号(contractCode);

                repository报价交车表.save(model报价交车表);
            }

            //3、更新LSH库存表，更新报价单号
            Lsh库存表Model lsh库存表Model = null;
            if (model报价单表.get库存编号() == null) {
                logger.error("此报价单表无库存编号！报价编号：" + quotedPriceCodeOrVin);
            } else {
                lsh库存表Model = lsh库存表Repository.findOne(model报价单表.get库存编号());
                lsh库存表Model.set报价编号(model报价单表.get报价编号());
                lsh库存表Model.set车辆零售状态("已卖");
                lsh库存表Repository.save(lsh库存表Model);
            }

            //顾客记录汇总：新车销售状态=16
            repository顾客记录汇总.updteNewCarStatusById(model报价单表.get顾客编号(), 16);

            //合同审批通过需要向财务发送消息
            SendMsgRoleUtil.sendMsgByFinance(flow.getPermit(),
                    flow.getUserName(),//销售行政
                    MessageType.Type.getName(MessageType.MSG_TYPE_CONTRACT),
                    null,
                    null,
                    MessageContext.getCheckCarSourcePass(DefaultValueConstant.MESSAGE_HEAD_AGREEMENT_PASS,
                            lsh车型Model.get车型详细(), r.get顾客姓名(), r.get电话号码(), entrance),
                    DefaultValueConstant.MESSAGE_SET_TYPE_IN_FANCE,
                    DefaultValueConstant.CHECK_CAR_SOURCE_YES,
                    r.get电话号码());

            //向销售顾问发送消息
            if (lsh库存表Model != null) {
                SendMsgRoleUtil.sendMsgBySale(lsh库存表Model,
                        flow,
                        model报价单表,
                        quotedPriceCodeOrVin,
                        r,
                        MessageContext.getCheckSourceSalePass(DefaultValueConstant.MESSAGE_HEAD_AGREEMENT_PASS,
                                lsh库存表Model.get生产号(), r.get顾客姓名(), r.get电话号码(), entrance),
                        entrance,
                        null);
            }


           /* MessageSettingModel msgSet调入财务 = messageSettingRepository.findByPermitAndType(flow.getPermit(), "2", "1");
            if (msgSet调入财务 != null) {
                用户Model m财务 = repository用户.findByPermitAndUserName(flow.getPermit(), "财务专员", msgSet调入财务.getUser());
                if (m财务 != null) {
                    String content = "合同审批已通过全部审批，车款为" + lsh车型Model.get车型详细() +
                            ",顾客姓名" + r.get顾客姓名() + ",顾客电话" + r.get电话号码();
                    LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), m财务.get用户名(), "合同", content, flow.getUserName(), r.get电话号码());
                }
            }*/


            //自动通过后，需要向自动通过的审批人发送消息
            for (PushApprovalWorkFlowModel pp : list) {
                if ("3".equals(pp.getApprovalStatus())) {
                    String contentAuto = "合同审批已自动通过全部审批，请留意车款为" + lsh车型Model.get车型详细() +
                            ",顾客姓名：" + r.get顾客姓名() + ",顾客电话：" + r.get电话号码() + "的合同审批";
                    //给审批人
                    LshMsgUtils.getLshMsg(list.get(0).getPermit(), list.get(0).getUserName(), pp.getPermit(), pp.getUserName(),
                            "合同", contentAuto, pp.getUserName(), r.get电话号码());

                    String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
                    String createTime = pp.getTranscationCode().substring(pp.getTranscationCode().length() - 19);
                    createTime = createTime.substring(0, 4) + "年" + createTime.substring(5, 7) + "月" + createTime.substring(8, 10) + "日";
                    String contentSales = "您于" + createTime +
                            "提交的车款为" + (StringUtils.isNullOrBlank(lsh车型Model.get车型详细()) ? lsh车型Model.get车型() : lsh车型Model.get车型详细()) +
                            "外观为" + 报价单表Model.get外观() +
                            "的审批申请于" + new SimpleDateFormat("yyyy年MM月dd日").format(list.get(0).getProcessTime().getTime()) +
                            "的合同审批已通过全部审批，客户姓名：" + r.get顾客姓名() + "，客户电话：" + r.get电话号码();
                    //给销售顾问
                    LshMsgUtils.getLshMsg(list.get(0).getPermit(), list.get(0).getUserName(), 报价单表Model.get许可(), 报价单表Model.get销售顾问(),
                            "合同", contentSales, pp.getUserName(), r.get电话号码());
                }
            }

            //修改保险金融状态和新增日志
            changeStatusAfterApproved(model报价单表, flow);

            getLastMsgToUpdateStatus(quotedPriceCodeOrVin, model报价单表, flow);

            // 判断车型是否改变，及相关处理
            this.updateOldOrNewRecord(model报价单表,ApprovalWorkFlowEnum.AGREEMENT);

            // 调用老财务的出入账确认按钮的逻辑
            setService.updateNewCarSaleMoneyForNewFinance(model报价单表.get报价编号(),model报价单表.get销售顾问(),model报价单表.get许可());


        } else if ("2".equals(approvalStatus)) {    // 驳回处理
            String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();//报价编号
            报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
            if (model报价单表 == null) {
                logger.error("报价单表为空！报价编号:" + quotedPriceCodeOrVin);
                return;
            }
            Lsh库存表Model lsh库存表Model = lsh库存表Repository.findOne(model报价单表.get库存编号());
            报价订单表Model model报价订单表 = repository报价订单表.findOne(model报价单表.get订单编号());
            顾客记录汇总Model r = repository顾客记录汇总.findOne(报价单表Model.get顾客编号());
            if (StringUtils.isNullOrBlank(r.get顾客姓名())) {
                r.set顾客姓名("无");
            }
            if (StringUtils.isNullOrBlank(r.get电话号码())) {
                r.set电话号码("无");
            }
            if (model报价单表.get订单编号() == null) {
                logger.error("此报价单表无订单编号！报价编号：" + quotedPriceCodeOrVin);
                return;
            }
            if ("是".equals(model报价订单表.get是否现定现交())) {
                model报价订单表.set是否现定现交("否");
                model报价订单表.set订单状态("订单C");
                repository报价订单表.save(model报价订单表);
            } else {
                //合同R状态设置不受条件限制，之后的条件在itask包判断
                //订单状态改为订单驳回(合同R)
                repository报价订单表.updateOrderStatusById(model报价单表.get订单编号(), "合同R");
                if (lsh库存表Model != null && 报价订单表Model != null && StringUtils.isNullOrBlank(报价订单表Model.get订单号())) { //Added by Tony  现订现交情况下，释放车辆
                    logger.warn("释放库存。库存编号={}", model报价单表.get库存编号());
                    lsh库存表Model.set车辆零售状态("未卖");
                    lsh库存表Model.set报价编号(null);
                    lsh库存表Repository.save(lsh库存表Model);
                }
                //回滚数据
                rollBackOrderData(model报价单表);
            }
            String content = "您提交的生产号为" + lsh库存表Model.get生产号() + "的车辆的合同审批已被驳回,客户姓名：" +
                    r.get顾客姓名() + ",客户电话：" + r.get电话号码() + ",原因" + flow.getRemark();
            LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), model报价单表.get销售顾问(), "合同",
                    content, flow.getUserName(), r.get电话号码());
            List appList = new ArrayList();
            appList.add(model报价单表.get销售顾问());
            JPush.sendPushForAndroidAndIos(content, content,
                    JsonObjectUtils.getJsonObject(flow.getType().toString(), "2", quotedPriceCodeOrVin, "",
                            "", model报价单表.get销售顾问()),
                    appList, JPush.Platforms.iTask);
        }
    }

    //订单退订
    private void postOrderWithdrawProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus) throws Exception {
        // 找到当前用户的索引
        int i = getCurrentStep(list, current_step);
        PushApprovalWorkFlowModel flow = list.get(i);
        String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();//报价编号
        报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
        报价订单表Model model报价订单表 = repository报价订单表.findOne(model报价单表.get订单编号());
        Lsh库存表Model lsh库存表Model = lsh库存表Repository.findOne(model报价单表.get库存编号());
        顾客记录汇总Model countUser = null;
        if (null != model报价单表 && null != model报价单表.get顾客编号()) {
            countUser = 顾客记录汇总Repository.findCusByCustomerID(model报价单表.get顾客编号());
        }

        if ("1".equals(approvalStatus)) {
            //1、库存表：车辆零售状态-未卖，报价单号-null
            lsh库存表Model.set车辆零售状态("未卖");
            lsh库存表Model.set报价编号(null);
            lsh库存表Repository.save(lsh库存表Model);
            //2、报价订单表：订单失销日期更新
            //注释清空审批通过状态，这会影响所有kpi的统计结果
//            model报价订单表.set订单审批通过日期(null);//将退订的审批通过日期置null(会导致退订后重新申请订单的订单状态不对)
            model报价订单表.set订单失销日期(new java.sql.Date(DateFormatUtils.getFormatDate("yyyy-MM-dd HH:mm:ss", new Date()).getTime()));
            model报价订单表.set订单状态("退订C");
            repository报价订单表.save(model报价订单表);

            //修改金融保险状态和新增日志
            changeStatusAfterWithdrawApproved(model报价单表, flow);
            顾客进店记录表Model model顾客进店记录表 = null;
            String id = repository顾客进店记录表.findBJBH(quotedPriceCodeOrVin);
            // 根据报价编号查找进店记录
            if(id!=null&&!id.trim().equals("")) {
                model顾客进店记录表 = repository顾客进店记录表.findOneByQuotedPriceCode(Integer.valueOf(id));
            }

            //销售平台界面取意向级别是取顾客记录汇总表新顾客级别,所以更新一下
            顾客记录汇总Model model顾客记录汇总 = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
            model顾客记录汇总.set新顾客级别("E:六个月以上订单");

            //需求813 战败  订单退订顾客状态设置为战败
            model顾客记录汇总.set顾客状态("战败");
            model顾客记录汇总.set战败日期(new java.sql.Date(new Date().getTime()));
            repository顾客记录汇总.save(model顾客记录汇总);

            //如果有进店记录且找到不是到店目的不是退订则修改记录
            if (null != model顾客进店记录表 && !"退订".equals(model顾客进店记录表.get到店目的())) {
                if("是".equals(model顾客进店记录表.get是否订单())) {//当天订单改为0
                    TrafficLogUtils.updateTrafficLogModel(model顾客进店记录表, 10);
                }else{//隔天订单改为-1
                    TrafficLogUtils.updateTrafficLogModel(model顾客进店记录表, 11);
                }
                repository顾客进店记录表.save(model顾客进店记录表);
                updateUserOrder(model报价单表, "退订");
            }else if(null == model顾客进店记录表){ //没有进店记录则新增
                String type = "退订";
                String re = saveStroe(model报价单表, countUser, type,"E:六个月以上订单");
                if (!"true".equals(re)) {
                    logger.error("新增进店记录异常");
                }
                updateUserOrder(model报价单表, "退订");
            }

            //订单退订之后，将报价付款详细的应付金额和实付金额置为0   2017-03-23  hyp
            repository报价付款详细.updateMoneyByQuoteNo(null, "0", model报价单表.get报价编号());

            //需求813 战败  订单退订后，插入战败表 和 跟进记录表
            if (model顾客记录汇总!=null) {
                TDefeatLogModel tdefeatmodel = new TDefeatLogModel();

                tdefeatmodel.setDefeatTime(new Timestamp(new Date().getTime()));
                tdefeatmodel.setCustId(model顾客记录汇总.get顾客编号());
                tdefeatmodel.setPermit(model顾客记录汇总.get许可());
                tdefeatmodel.setCustIdState(0);
                tdefeatmodel.setCustName(model顾客记录汇总.get顾客姓名());
                tdefeatmodel.setCustPhone(model顾客记录汇总.get电话号码());
                tdefeatmodel.setCustSex(model顾客记录汇总.get顾客性别());
                tdefeatmodel.setInterestRank(model顾客记录汇总.get新顾客级别());
                tdefeatmodel.setUserName(model顾客记录汇总.get所属销售顾问());
                tdefeatmodel.setDefeatType(0);
                tdefeatmodel.setSource(model顾客记录汇总.get顾客渠道());
                tdefeatmodel.setGuardBank(model顾客记录汇总.get保有品牌());
                tdefeatmodel.setInterestCar(model顾客记录汇总.get意向车型A());
                tdefeatmodel.setForFilingDate(model顾客记录汇总.get留档日期());

                跟进记录表Model dModel= new 跟进记录表Model();
                dModel.set许可(model顾客记录汇总.get许可());
                dModel.set电话号码(model顾客记录汇总.get电话号码());
                dModel.set销售顾问(model顾客记录汇总.get销售顾问());
                dModel.set跟进日期(new java.sql.Date(new Date().getTime()));
                dModel.set跟进结果("新车战败");
                //dModel.set下次跟进时间();
                //dModel.set战败原因("");
                dModel.set跟进备注("销售平台退订");
                dModel.set战败备注("销售平台退订");
                dModel.set模式("跟进");
                dModel.set更新账号(model顾客记录汇总.get更新账号());
                dModel.set更新时间(new Timestamp(new Date().getTime()));

                repository跟进记录表.save(dModel);
                TDefeatLogRepository.save(tdefeatmodel);
            }

            // 新财务需求，修改收款状态和开票状态
            logger.info("修改财务状态-订单退订阶段。报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
            ResultData result1 = financeReceivablesService.updateFinanceReceivablesStatus(model报价单表.get初始报价单号(),FinanceConstant.RECEIVABLES_NOT_COMPLETE);
            if (null == result1 || (null != result1 && !"true".equalsIgnoreCase(result1.getResult()))) {
                logger.error("修改财务状态-订单退订阶段：修改收款状态失败！报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
            }


        } else if ("2".equals(approvalStatus)) {
            顾客记录汇总Model r = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
            if (StringUtils.isNullOrBlank(r.get顾客姓名())) {
                r.set顾客姓名("无");
            }
            if (StringUtils.isNullOrBlank(r.get电话号码())) {
                r.set电话号码("无");
            }
            //退订驳回
            repository报价订单表.updateOrderStatusById(model报价订单表.get订单编号(), "退订R");

            //回滚数据
            rollBackOrderData(model报价单表);

            String content = "您提交的生产号为" + lsh库存表Model.get生产号() + "的车辆的订单退订审批已被驳回,客户姓名：" +
                    r.get顾客姓名() + ",客户电话：" + r.get电话号码() + ",原因" + flow.getRemark();
            LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), model报价单表.get销售顾问(), "订单",
                    content, flow.getUserName(), r.get电话号码());
            List appList = new ArrayList();
            appList.add(model报价单表.get销售顾问());
            JPush.sendPushForAndroidAndIos(content, content,
                    JsonObjectUtils.getJsonObject(flow.getType().toString(), "2", quotedPriceCodeOrVin, "",
                            "", model报价单表.get销售顾问()),
                    appList, JPush.Platforms.iTask);
        }
        try {
            //324后市场订单修改，需要更新
            if ("1".equals(approvalStatus)) {
                //退订通过
                PushApprovalWorkFlowModel flows = list.get(0);
                if (flows != null) {
                    String quotedPriceCodeOrVins = flow.getQuotedPriceCodeOrVin();//报价编号
                    if (!Strings.isNullOrEmpty(quotedPriceCodeOrVins)) {
                        报价单表Model model报价单表s = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
                        if (model报价单表s != null) {
                            CancelAfterMarkQueto(model报价单表s);
                        }
                    }
                }

            } else {
                // 退订不通过
                PushApprovalWorkFlowModel flows = list.get(0);
                if (flows != null) {
                    String quotedPriceCodeOrVins = flow.getQuotedPriceCodeOrVin();//报价编号
                    if (!Strings.isNullOrEmpty(quotedPriceCodeOrVins)) {
                        报价单表Model model报价单表s = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
                        if (model报价单表s != null) {
                            getLastMsgToUpdateStatus(quotedPriceCodeOrVins, model报价单表s, flows);
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error("订单退订部分，后市场更新失败", e);
        }
    }

    private void CancelAfterMarkQueto(报价单表Model model报价单表s) {
        //根据初始报价单号 把已经在_精品中的全部改成退订
        List orderList = pushApprovalWorkFlowRepository.getAfterMarkOrderList(model报价单表s.get初始报价单号());
        if (orderList != null && orderList.size() > 0) {
            for (int i = 0; i < orderList.size(); i++) {
                Map reMap = (Map) orderList.get(i);
                if (reMap != null) {
                    if (reMap.get("id") != null) {
                        String id = reMap.get("id").toString();
                        if (!Strings.isNullOrEmpty(id)) {
                            报价精品详细表精品Model updatemodel = repository报价精品详细精品表.findOne(Integer.parseInt(id));
                            updatemodel.setOrderStatus("9");
                            repository报价精品详细精品表.save(updatemodel);
                        }
                    }
                }

            }
        }
    }

    private void postIntentOrderWithdrawProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus) throws Exception {
        // 找到当前用户的索引
        int i = getCurrentStep(list, current_step);
        PushApprovalWorkFlowModel flow = list.get(i);
        String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();//报价编号
        报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
        报价订单表Model model报价订单表 = repository报价订单表.findOne(model报价单表.get订单编号());
        // Lsh库存表Model lsh库存表Model = lsh库存表Repository.findOne(model报价单表.get库存编号());
        if ("1".equals(approvalStatus)) {
//            repository报价订单表.updateOrderStatusById(model报价订单表.get订单编号(), null);
            // 意向订单退订审批通过后写入订单失销日期
            model报价订单表.set订单状态(null);
            model报价订单表.set订单失销日期(new java.sql.Date(DateFormatUtils.getFormatDate("yyyy-MM-dd HH:mm:ss", new Date()).getTime()));

            //修改金融保险状态和新增日志
            changeStatusAfterWithdrawApproved(model报价单表, flow);

            //订单退订之后，将报价付款详细的应付金额和实付金额置为0   2017-03-23  hyp
            repository报价付款详细.updateMoneyByQuoteNo("0", "0", model报价单表.get报价编号());

            // 新财务需求，修改收款状态和开票状态
            logger.info("修改财务状态-意向订单退订阶段。报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
            ResultData result1 = financeReceivablesService.updateFinanceReceivablesStatus(model报价单表.get初始报价单号(),FinanceConstant.RECEIVABLES_NOT_COMPLETE);
            if (null == result1 || (null != result1 && !"true".equalsIgnoreCase(result1.getResult()))) {
                logger.error("修改财务状态-意向订单退订阶段：修改收款状态失败！报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
            }

        } else if ("2".equals(approvalStatus)) {
            //订单状态改为订单驳回(订单R)
            repository报价订单表.updateOrderStatusById(model报价单表.get订单编号(), "退订R");
            顾客记录汇总Model r = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
            if (StringUtils.isNullOrBlank(r.get顾客姓名())) {
                r.set顾客姓名("无");
            }
            if (StringUtils.isNullOrBlank(r.get电话号码())) {
                r.set电话号码("无");
            }
            //回滚数据
            rollBackOrderData(model报价单表);

            String content = "您提交的意向订单退订审批已被驳回,客户姓名：" + r.get顾客姓名() + ",客户电话：" + r.get电话号码() + ",原因" + flow.getRemark();
            LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), model报价单表.get销售顾问(), "订单",
                    content, flow.getUserName(), r.get电话号码());
            List appList = new ArrayList();
            appList.add(model报价单表.get销售顾问());
            JPush.sendPushForAndroidAndIos(content, content,
                    JsonObjectUtils.getJsonObject(flow.getType().toString(), "2", quotedPriceCodeOrVin, "",
                            "", model报价单表.get销售顾问()),
                    appList, JPush.Platforms.iTask);
        }
    }

    //订单修改
    private void postOrderModifyProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus) throws Exception {
        // 找到当前用户的索引
        int i = getCurrentStep(list, current_step);
        PushApprovalWorkFlowModel flow = list.get(i);
        String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();//报价编号
        报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
        报价单表Model 报价单表Model2 = repository报价单表.getListByInitQuoteNumbers(model报价单表.get初始报价单号()).get(0);
        Lsh库存表Model lsh库存表Model = lsh库存表Repository.findOne(model报价单表.get库存编号());
        //1、报价订单表：订单修改日期更新，历史订单编号写入，订单状态-订单C
        报价订单表Model model报价订单表 = repository报价订单表.findOne(model报价单表.get订单编号());
        if ("1".equals(approvalStatus)) {
            model报价订单表.set订单审批通过日期(new Timestamp(new Date().getTime()));
            model报价订单表.set订单签署日期(new java.sql.Date(new java.util.Date().getTime()));
            model报价订单表.set订单修改日期(new java.sql.Date(DateFormatUtils.getFormatDate("yyyy-MM-dd HH:mm:ss", new Date()).getTime()));
            model报价订单表.set订单状态("订单C");
            model报价订单表.set历史订单编号(model报价订单表.get订单编号());
            repository报价订单表.save(model报价订单表);

            if (model报价单表.get库存编号() != null) { //修改当前所挂车状态为已卖，而不管如何修改订单
                lsh库存表Repository.updateQuotedPriceCodeOrVinById(model报价单表.get库存编号(), model报价单表.get报价编号());
            }
            // 此处不能通过库存编号 == null来判断是否意向订单，因为意向订单审批通过后，会生成新的虚拟车，并将虚拟库存编号写到报价单的库存编号字段
            // 用上一个还原点的报价单对应的报价订单表订金状态为意向金来判断
            报价订单表Model orMo = repository报价订单表.findOne(报价单表Model2.get订单编号());
            if ("意向金".equals(orMo.get订金类型())) {//意向订单 转为订单
                //a.订单号 生成
                String timeStr = new SimpleDateFormat("yyMMdd").format(new Date());
                String orderNum = flow.getPermit() + timeStr + lsh库存表Model.get生产号();
                model报价订单表.set订单号(orderNum);
                repository报价订单表.save(model报价订单表);

                model报价单表.set订单编号(model报价订单表.get订单编号());
                repository报价单表.save(model报价单表);
                //b.修改顾客状态 转为 已订单
                顾客记录汇总Model model顾客记录汇总 = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
                model顾客记录汇总.set是否订单("是");
                model顾客记录汇总.set新顾客级别("无评级:已经订单或交车");
                model顾客记录汇总.set顾客状态("已订单");
                model顾客记录汇总.set新车销售状态(13);
                repository顾客记录汇总.save(model顾客记录汇总);
                //c.顾客订单记录表新增记录
                顾客进店记录表Model model顾客进店记录表 = repository顾客进店记录表.findOneByQuotedPriceCode(model报价单表.get报价编号());
                // 路松
                //修改原因:顾客订单记录.订单编号 <> 报价订单表.订单编号
                //原有程序 将这两个 订单编号 混在一起，导致 顾客订单记录 表数据出错
                //现修改： 逻辑 -- 顾客编号、库存编号在 顾客订单记录 表中确定唯一 信息记录，有则修改，无则新增
                顾客订单记录Model md = null;
                if (model报价单表.get顾客编号() == null) {
                    logger.error("报价单表无顾客编号！报价编号：" + model报价单表.get报价编号());
                }
                if (model报价单表.get库存编号() == null) {
                    logger.error("报价单表无库存编号！报价编号：" + model报价单表.get报价编号());
                }
                List<顾客订单记录Model> 顾客订单记录Models = repository顾客订单记录.findOrderByCustIdAndSrockId(model报价单表.get顾客编号(), model报价单表.get库存编号());
                if (顾客订单记录Models != null && !顾客订单记录Models.isEmpty()) {
                    md = 顾客订单记录Models.get(0);
                } else {
                    md = new 顾客订单记录Model();
                }
//                顾客订单记录Model md = new 顾客订单记录Model();
//                md.set订单编号(model报价订单表.get订单编号());
                md.set许可(model报价单表.get许可());
                if (model报价单表.get顾客编号() == null) {
                    logger.error("报价单表无顾客编号！报价编号：" + model报价单表.get报价编号());
                }
                md.set顾客编号(model报价单表.get顾客编号());
                if (model报价单表.get车型编号() == null) {
                    logger.error("报价单表无车型编号！车型编号：" + model报价单表.get报价编号());
                }
                md.set车型(model报价单表.get车型编号());
                if (model顾客进店记录表 != null) {
                    if (model顾客进店记录表.get销售顾问() == null) {
                        logger.error("顾客进店记录表没有销售顾问！进店编号：" + model顾客进店记录表.get进店编号());
                    }
                    md.set销售顾问(model顾客进店记录表.get销售顾问());
                }
                if (model报价订单表.get订单签署日期() == null) {
                    logger.error("订单签署日期为空！订单编号：" + model报价订单表.get订单编号());
                }
                md.set订单日期(model报价订单表.get订单签署日期());
                md.set库存编号(model报价单表.get库存编号());
                md.set状态("已订单");
                md.set销售顾问(model报价单表.get销售顾问());
                repository顾客订单记录.save(md);

            }

            // 2、如果订单修改涉及换车，库存表：老的（车辆零售状态-未卖，报价单号-null），新的（车辆零售状态-已卖，更新报价单号）
            //根据报价编号查询初始报价编号，然后根据初始报价编号查询是否还原点=是的数据（即老的报价编号）
            doChangeCarStatus(model报价单表);

            顾客记录汇总Model model汇总 = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
            String startquotedPriceCodeOrVin = repository顾客进店记录表.findBJBH(quotedPriceCodeOrVin);
            Integer inNo=repository顾客进店记录表.findJDBH(quotedPriceCodeOrVin);
            顾客进店记录表Model model顾客进店记录表 = null;
            if(startquotedPriceCodeOrVin != null) {
                model顾客进店记录表 = repository顾客进店记录表.findOneByQuotedPriceCode(Integer.valueOf(startquotedPriceCodeOrVin));
            }
            String nowDay = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
            //如果有进店记录

            if (null != model顾客进店记录表 && model报价订单表.get订单申请日期() != null &&  nowDay.equals(new SimpleDateFormat("yyyy-MM-dd").format(model报价订单表.get订单申请日期()))) {
                // 更新顾客进店记录表
                /*model顾客进店记录表.set到店目的("办手续");
                model顾客进店记录表.set是否订单("是");
                model顾客进店记录表.set是否报价("是");
                model顾客进店记录表.set是否首次到店("否");
                model顾客进店记录表.set意向车型A(model汇总.get意向车型A());
                model顾客进店记录表.set客户级别("无评级:已经订单或交车");*/
                model顾客进店记录表.set意向车型A(model汇总.get意向车型A());
                Integer count = repository报价订单表.selectCountOrder(model顾客进店记录表.get报价编号());

//                if(count>0){//进店意向订单
                //  TrafficLogUtils.updateTrafficLogModel(model顾客进店记录表, 9);
                model顾客进店记录表.set进店编号(inNo);
                //bug 5367

                顾客进店记录表Model customer= repository顾客进店记录表.getOrderState(inNo);
                if (customer!=null&&!Strings.isNullOrEmpty(customer.get是否订单())&&customer.get是否订单().equals("是")){
                    model顾客进店记录表.set是否订单("是");
                }else {
                    model顾客进店记录表.set是否订单("否");
                }
                if (customer!=null&&!Strings.isNullOrEmpty(customer.get是否报价())&&customer.get是否报价().equals("是")){
                    model顾客进店记录表.set是否报价("是");
                }else {
                    model顾客进店记录表.set是否报价("否");
                }
                //解决bug 6207 不显示订单数
                if(count>0) {
                    model顾客进店记录表.set接待备注("意向订单转订单");
                    model顾客进店记录表.set到店目的("其他");
                }else {
                    model顾客进店记录表.set到店目的("办手续");
                }

                model顾客进店记录表.set客户级别("无评级:已经订单或交车");

//                }else {//非意向订单
//                    TrafficLogUtils.updateTrafficLogModel(model顾客进店记录表, 4);
//                }

                repository顾客进店记录表.save(model顾客进店记录表);
            }
            //未进店新增进店记录(只有意向订单转订单才能记录进店日志)
//            if (ApprovalWorkFlowEnum.ORDER_UPDATE == flow.getType() && isSaveLog(model报价单表.get初始报价单号())) {
//                if (model顾客进店记录表 == null || DateFormatUtils.isNoStore(model顾客进店记录表.get到店时间())) {
//                    saveStroe(model报价单表, model汇总, "订单","无评级:已经订单或交车");
//                }
//            }
            //设置还原点
            repository报价单表.set还原点AndTime(model报价单表.get报价编号(), "是", DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));

            // 判断车型是否改变，及相关处理
            this.updateOldOrNewRecord(model报价单表,ApprovalWorkFlowEnum.ORDER_UPDATE);

            // 新财务需求，修改收款状态和开票状态
            logger.info("修改财务状态-订单修改阶段。报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
            ResultData result1 = financeReceivablesService.updateFinanceReceivablesStatus(model报价单表.get初始报价单号(),FinanceConstant.RECEIVABLES_NOT_COMPLETE);
            if (null == result1 || (null != result1 && !"true".equalsIgnoreCase(result1.getResult()))) {
                logger.error("修改财务状态-订单修改阶段：修改收款状态失败！报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
            }

        } else if ("2".equals(approvalStatus)) {
            顾客记录汇总Model r = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
            if (StringUtils.isNullOrBlank(r.get顾客姓名())) {
                r.set顾客姓名("无");
            }
            if (StringUtils.isNullOrBlank(r.get电话号码())) {
                r.set电话号码("无");
            }

            //2017-02-13新增：如果涉及换成，新的库存的车辆零售状态=未卖；报价编号=null；
            //根据报价编号查询初始报价编号，然后根据初始报价编号查询是否还原点=是的数据（即老的报价编号）
            if (model报价单表.get初始报价单号() != null) {
                List<报价单表Model> model报价单表OldList = repository报价单表.getListByInitQuoteNumberAnd是否还原点(model报价单表.get初始报价单号());
                //判断是否有换车，找到还原点=是的报价单表的库存编号，与当前的库存编号是否一致
                if (model报价单表OldList.size() > 0) {
                    报价单表Model model报价单表Old = model报价单表OldList.get(0);
                    if (!model报价单表.get库存编号().equals(model报价单表Old.get库存编号())) { //涉及到换车或者从意向订单到订单，需要更新最新挂车的状态为未卖
                        lsh库存表Repository.updateLshStoreStatusById(model报价单表.get库存编号());
                    }
                }
            }

            //订单状态改为订单驳回(订单R)
            repository报价订单表.updateOrderStatusById(model报价单表.get订单编号(), "订单R");

            //回滚数据
            rollBackOrderData(model报价单表);

            String content = "您提交的生产号为" + lsh库存表Model.get生产号() + "的车辆的订单修改审批已被驳回,客户姓名：" +
                    r.get顾客姓名() + "，客户电话：" + r.get电话号码() + ",原因" + flow.getRemark();
            List appList = new ArrayList();
            appList.add(model报价单表.get销售顾问());
            JPush.sendPushForAndroidAndIos(content, content,
                    JsonObjectUtils.getJsonObject(flow.getType().toString(), "2", quotedPriceCodeOrVin, "",
                            "", model报价单表.get销售顾问()),
                    appList, JPush.Platforms.iTask);
        }
    }

    private void postIntentOrderModifyProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus) throws Exception {
        // 找到当前用户的索引
        int i = getCurrentStep(list, current_step);
        PushApprovalWorkFlowModel flow = list.get(i);
        String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();//报价编号
        报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
        报价订单表Model model报价订单表 = repository报价订单表.findOne(model报价单表.get订单编号());
        // Lsh库存表Model lsh库存表Model = lsh库存表Repository.findOne(model报价单表.get库存编号());
        if ("1".equals(approvalStatus)) {
            //设置还原点
            repository报价单表.set还原点AndTime(model报价单表.get报价编号(), "是", DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
            //通过，意向订单C
            model报价订单表.set订单状态("意向订单C");
            repository报价订单表.save(model报价订单表);

            if (StringUtils.isNullOrBlank(model报价单表.get库存编号())) {
                // 生成虚拟车,并把虚拟车关联到报价单表
                virtualStockModelRepository.setNewVirtualStockCode();   // 虚拟车id + 1
                Integer virtualId = virtualStockModelRepository.getVirtualStockCode();
                String virtualVin = String.format("IRISTechnologies%08d", virtualId);
                Lsh库存表Model lsh库存表Model = new Lsh库存表Model();
                lsh库存表Model.set车型编号(model报价单表.get车型编号());
                lsh库存表Model.set生产号(virtualVin);
                lsh库存表Model.set车架号(virtualVin);
                lsh库存表Model.set颜色(model报价单表.get外观());
                lsh库存表Model.set内饰(model报价单表.get内饰());
                lsh库存表Model.set加配配置(null);
                lsh库存表Model.set加配价格含税(null);
                lsh库存表Model.set标配Msrp含税(model报价单表.get原价());
                lsh库存表Model.set实际Msrp含税(model报价单表.get原价());
                lsh库存表Model.set车辆零售状态("未卖");
                lsh库存表Model.set所属经销商(model报价单表.get许可());
                lsh库存表Model.setIsDelete((byte) 0);
                lsh库存表Model.set报价编号(model报价单表.get报价编号());
                lsh库存表Repository.save(lsh库存表Model);
                model报价单表.set库存编号(lsh库存表Model.get库存编号()); // 报价单关联虚拟车
            }

            // 判断车型是否改变，及相关处理
            this.updateOldOrNewRecord(model报价单表,ApprovalWorkFlowEnum.ORDER_INTENTION_UPDATE);

            // 新财务需求，修改收款状态和开票状态
            logger.info("修改财务状态-意向订单修改阶段。报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
            ResultData result1 = financeReceivablesService.updateFinanceReceivablesStatus(model报价单表.get初始报价单号(),FinanceConstant.RECEIVABLES_NOT_COMPLETE);
            if (null == result1 || (null != result1 && !"true".equalsIgnoreCase(result1.getResult()))) {
                logger.error("修改财务状态-意向订单修改阶段：修改收款状态失败！报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
            }

        } else if ("2".equals(approvalStatus)) {
            顾客记录汇总Model r = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
            if (StringUtils.isNullOrBlank(r.get顾客姓名())) {
                r.set顾客姓名("无");
            }
            if (StringUtils.isNullOrBlank(r.get电话号码())) {
                r.set电话号码("无");
            }

            //修改报价单表状态为驳回失效
            model报价单表.setInvalidReason("2");
            repository报价单表.save(model报价单表);

            repository报价订单表.updateOrderStatusById(model报价订单表.get订单编号(), "意向订单R");
            String content = "您提交的意向订单修改审批已被驳回,客户姓名：" + r.get顾客姓名() + ",客户电话：" + r.get电话号码() + ",原因" + flow.getRemark();
            LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), model报价单表.get销售顾问(), "订单",
                    content, flow.getUserName(), r.get电话号码());
            List appList = new ArrayList();
            appList.add(model报价单表.get销售顾问());
            JPush.sendPushForAndroidAndIos(content, content,
                    JsonObjectUtils.getJsonObject(flow.getType().toString(), "2", quotedPriceCodeOrVin, "",
                            "", model报价单表.get销售顾问()),
                    appList, JPush.Platforms.iTask);
        }
    }

//    @Transactional
//    private void postCarTransferInProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus) throws Exception {
//        // 取出当前用户的索引
//        int i = getCurrentStep(list, current_step);
//        PushApprovalWorkFlowModel flow = list.get(i);
//        Lsh库存表Model lsh库存表Model = lsh库存表Repository.findLshRecordByVin(flow.getQuotedPriceCodeOrVin());
//        List<CarTransferLogModel> carTransferLogModelList = carTransferLogRepository.findByStockId(lsh库存表Model.get库存编号());
//        CarTransferLogModel carLog = carTransferLogModelList.get(0);
//        Lsh车型Model lsh车型Model = lsh车型Repository.findOne(lsh库存表Model.get车型编号());
//        Timestamp ts = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
//        Date dt = DateFormatUtils.getFormatDate("yyyy-MM-dd", new Date());
//        //本店调入审批通过
//        if ("1".equals(approvalStatus)) {
//            //生成调出审批数据，许可，type，
//            PushApprovalWorkFlowModel pw = new PushApprovalWorkFlowModel();
//            pw.setType(9);
//            pw.setQuotedPriceCodeOrVin(flow.getQuotedPriceCodeOrVin());
//            pw.setPermit(lsh库存表Model.get所属经销商());
//            addApprovalWorkFlow(pw, flow.getUserName());
//
//            //1.如果本店或者他店最后一级审批人通过，调整调车物流状态为"调入申请确认",更新调入外部申请日
//            lsh库存表Repository.updateLogisticsStatusById(lsh库存表Model.get库存编号(), "调入申请确认", dt);
//            //2.发送消息到对方管理层App,对方经销商=所属经销商，接收人=设置表的permit人
//            //消息内容
//            String name调入经销商名 = lsh经销商表Repository.findNameByPermit(lsh库存表Model.get调入经销商());
//            String content = MessageContext.getPostCarTransferInProcess(name调入经销商名, lsh库存表Model.get生产号(), lsh车型Model.get车型详细());
//            //get incomming first Approver
//            PushApprovalItemSettingModel pushSet = pushApprovalItemSettingRepository.getModelByPermitAndTypeAndBrand(
//                    lsh库存表Model.get所属经销商(), flow.getType() + 1, null);
//            if (pushSet != null) {
//                //如果有接收人
//                Lsh消息Model sendMsg = LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(),
//                        lsh库存表Model.get所属经销商(), pushSet.getStep1(), "调车调出", content,
//                        flow.getUserName(), carLog.getCustomTel());
//                List appList = new ArrayList();
//                appList.add(pushSet.getStep1());
//                JPush.sendPushForAndroidAndIos(content, content,
//                        JsonObjectUtils.getJsonObject("9", "1", flow.getQuotedPriceCodeOrVin(), "",
//                                "", ""),
//                        appList, JPush.Platforms.iMgt);
//            }
//            //给销售行政发
//            String content销售行政 = MessageContext.getPostCarTransferInProcessForSaleAdmin(getFormatDate(carLog.getInternalApplyDate()),
//                    lsh库存表Model.get生产号(), lsh车型Model.get车型详细(), carLog.getCustomName(), carLog.getCustomTel(), DefaultValueConstant.SET_PASS);
//            LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), carLog.getInternalApplyUser(), "调车调入", content销售行政,
//                    flow.getUserName(), carLog.getCustomTel());
//        } else if ("2".equals(approvalStatus)) {
//            //本店调入审批驳回
//            lsh库存表Repository.updateLogisticsStatusById(lsh库存表Model.get库存编号(), null, null);
//            //发送消息到销售行政
//            String content = MessageContext.getPostCarTransferInProcessForSaleAdmin(getFormatDate(carLog.getInternalApplyDate()),
//                    lsh库存表Model.get生产号(), lsh车型Model.get车型详细(), carLog.getCustomName(), carLog.getCustomTel(), DefaultValueConstant.SET_FULL);
//            LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), carLog.getInternalApplyUser(), "调车调入", content,
//                    flow.getUserName(), carLog.getCustomTel());
//            //驳回之后修改为“SC/CDO可见”
//            Lsh库存内部可见Model invisiM = lsh库存内部可见Repository.findBystocknumber(lsh库存表Model.get库存编号());
//            if (invisiM != null) {
//                lsh库存内部可见Repository.updateStatusById("SC/CDO可见", invisiM.get库存内部可见编号());
//            }
//
//        }
//    }

//    @Transactional
//    private void postCarTransferOutProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus) throws Exception {
//        // 取出当前用户的索引
//        int i = getCurrentStep(list, current_step);
//        PushApprovalWorkFlowModel flow = list.get(i);
//        Lsh库存表Model lsh库存表Model = lsh库存表Repository.findLshRecordByVin(flow.getQuotedPriceCodeOrVin());
//        Lsh车型Model lsh车型Model = lsh车型Repository.findOne(lsh库存表Model.get车型编号());
//        Timestamp ts = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
//        Date dt = DateFormatUtils.getFormatDate("yyyy-MM-dd", new Date());
//        //调出审批通过
//        if ("1".equals(approvalStatus)) {
//            //1、通过,修改调车物流状态为"调出申请确认"
//            //调车物流状态变为3时调出财务状态自动变为'等待开调车增值票/付款'，告知A店和B店财务。写入调出确认日期
//            lsh库存表Repository.updateLshStoreStaById(lsh库存表Model.get库存编号(), "调出申请确认", dt, "等待开调车增值票/付款");
//
//            //3.更新carTransFerLog表
//            List<CarTransferLogModel> carTransferLogModelList = carTransferLogRepository.findByStockId(lsh库存表Model.get库存编号());
//            CarTransferLogModel carLog = carTransferLogModelList.get(0);
//            if (StringUtils.isNullOrBlank(carLog.getCustomName())) {
//                carLog.setCustomName("无");
//            }
//            if (StringUtils.isNullOrBlank(carLog.getCustomTel())) {
//                carLog.setCustomTel("无");
//            }
//            carLog.setOutConfirmUser(flow.getUserName());
//            carLog.setOutConfirmDate(java.sql.Date.valueOf(LocalDate.now()));
//            carTransferLogRepository.save(carLog);
//
//            //4、发送消息到调入经销商管理层app，确认审批通过
//            //查询调入申请审批的流水,取最后审批时间的管理层账号
//            List<PushApprovalWorkFlowModel> list调入 = pushApprovalWorkFlowRepository2.findByPermitAndTypeAndVin(8,
//                    lsh库存表Model.get调入经销商(), flow.getQuotedPriceCodeOrVin());
//            PushApprovalWorkFlowModel flow调入 = list调入.get(0);
//            String content调入 = "您于" + getFormatDate(carLog.getInternalApplyDate()) + "提交的生产号为" +
//                    lsh库存表Model.get生产号() + ",车款为" + lsh车型Model.get车型详细() + "的调车申请于" + new SimpleDateFormat("yyyy年MM月dd日").format(new Date()) + "已通过外部审批" +
//                    ",顾客姓名：" + carLog.getCustomName() + ",顾客电话：" + carLog.getCustomTel();
//            Lsh消息Model m1 = LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow调入.getPermit(), flow调入.getUserName(),
//                    "调车调出", content调入, flow.getUserName(), carLog.getCustomTel());
//
//            List appList = new ArrayList();
//            appList.add(flow调入.getUserName());
//            JPush.sendPushForAndroidAndIos(content调入, content调入,
//                    JsonObjectUtils.getJsonObject("9", "1", flow.getQuotedPriceCodeOrVin(), "",
//                            "", ""),
//                    appList, JPush.Platforms.iMgt);
//
//            //5、发送消息到调入经销商销售行政
//            String isEmegency = carLog.getIsEmegency();
//            String isEmegencyCn = null;
//            if ("0".equals(isEmegency)) {
//                isEmegencyCn = "紧急";
//            } else {
//                isEmegencyCn = "非紧急";
//            }
//            String expectedLateInStockDate = getFormatDate(carLog.getExpectedLateInStockDate());
//            String name1 = lsh经销商表Repository.findNameByPermit(lsh库存表Model.get所属经销商());
//            String content调入行政 = "贵司于" + getFormatDate(carLog.getInternalApplyDate()) + "提交的生产号为" +
//                    lsh库存表Model.get生产号() + ",车款为" + lsh车型Model.get车型详细() + "的调车申请于" + new SimpleDateFormat("yyyy年MM月dd日").format(new Date())
//                    + "已经通过外部审批，调出经销商为" + name1 + "，属于" + isEmegencyCn + "调车，最晚入库日期为" + expectedLateInStockDate +
//                    ",顾客姓名：" + carLog.getCustomName() + ",顾客电话：" + carLog.getCustomTel();
//            Lsh消息Model m2 = LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow调入.getPermit(), carLog.getInternalApplyUser(),
//                    "调车调出", content调入行政, flow.getUserName(), carLog.getCustomTel());
//            //6、发送消息到调出经销商行政(messageSetting表的：许可=调出经销商许可，check=1，type=3的)
//            MessageSettingModel msgSet调出行政 = messageSettingRepository.findByPermitAndType(flow.getPermit(), "3", "1");
//            if (msgSet调出行政 != null) {
//                用户Model m = repository用户.findByPermitAndUserName(msgSet调出行政.getPermit(), "销售行政", msgSet调出行政.getUser());
//                if (m != null) {
//                    String name = lsh经销商表Repository.findNameByPermit(lsh库存表Model.get调入经销商());
//                    String content调出行政 = "贵司管理层于" + new SimpleDateFormat("yyyy年MM月dd日").format(new Date()) + "已经确认生产号为" +
//                            lsh库存表Model.get生产号() + ",车款为" + lsh车型Model.get车型详细() + "的车辆将调出,调入经销商为" + name + "，属于" +
//                            isEmegencyCn + "调车，最晚入库日期为" + getFormatDate(carLog.getExpectedLateInStockDate());
//                    LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), m.get许可(), m.get用户名(), "调车调出", content调出行政, flow.getUserName(), carLog.getCustomTel());
//                }
//            }
//
//            //7、发送消息到调入经销商财务，确认需要付款的金(messageSetting表的：许可=调入经销商许可，check=1，type=2的)
//            MessageSettingModel msgSet调入财务 = messageSettingRepository.findByPermitAndType(lsh库存表Model.get调入经销商(), "2", "1");
//            if (msgSet调入财务 != null) {
//                用户Model m财务 = repository用户.findByPermitAndUserName(lsh库存表Model.get调入经销商(), "财务专员", msgSet调入财务.getUser());
//                if (m财务 != null) {
//                    String latestDate = null;
//                    if (carLog.getExpectedLateMoneyInAccount() == null) {
//                        latestDate = "";
//                    } else {
//                        latestDate = getFormatDate(carLog.getExpectedLateMoneyInAccount());
//                    }
//                    String name = lsh经销商表Repository.findNameByPermit(lsh库存表Model.get调入经销商());
//                    String content调入财务 = "贵司于" + getFormatDate(carLog.getInternalApplyDate()) + "提交的生产号为" +
//                            lsh库存表Model.get生产号() + ",车款为" + lsh车型Model.get车型详细() + "的调车申请于" + getFormatDate(carLog.getOutConfirmDate()) + "已经通过外部审批," +
//                            "调出经销商为" + name + "，协商调车款项金额（不含税）为" + lsh库存表Model.get协商调车款项金额() + "元,最晚款项到账日期为" + latestDate +
//                            ",顾客姓名：" + carLog.getCustomName() + "，顾客电话：" + carLog.getCustomTel();
//                    LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), m财务.get许可(), m财务.get用户名(), "调车调出", content调入财务, flow.getUserName(), carLog.getCustomTel());
//                }
//            }
//
//            //8/发送消息到调出经销商财务，确认需要开票的金额(messageSetting表的：许可=调入经销商许可，check=1，type=4)
//            MessageSettingModel msgSet调出财务 = messageSettingRepository.findByPermitAndType(flow.getPermit(), "4", "1");
//            if (msgSet调出财务 != null) {
//                用户Model m调出财务 = repository用户.findByPermitAndUserName(lsh库存表Model.get所属经销商(), "财务专员", msgSet调出财务.getUser());
//                if (m调出财务 != null) {
//                    String name = lsh经销商表Repository.findNameByPermit(lsh库存表Model.get调入经销商());
//                    String latestDate = null;
//                    if (carLog.getExpectedLateMoneyInAccount() == null) {
//                        latestDate = "";
//                    } else {
//                        latestDate = getFormatDate(carLog.getExpectedLateMoneyInAccount());
//                    }
//                    String content调出财务 = "贵司管理层于" + getFormatDate(carLog.getOutConfirmDate()) + "已经确认生产号为" +
//                            lsh库存表Model.get生产号() + ",车款为" + lsh车型Model.get车型详细() + "的车辆将调出,调入经销商为" + name + "，协商调车款项金额（不含税）为" +
//                            lsh库存表Model.get协商调车款项金额() + "元，最晚款项到账日期为" + latestDate;
//                    LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), m调出财务.get许可(), m调出财务.get用户名(), "调车调出", content调出财务, flow.getUserName(), carLog.getCustomTel());
//                }
//            }
//        } else if ("2".equals(approvalStatus)) {
//            lsh库存表Repository.updateLogisticsStatusById(lsh库存表Model.get库存编号(), null, null);
//            //1、他店调出驳回后，发送消息到调入经销商管理层APP，确认审批驳回
//            //查询调入申请审批的流水,取最后审批时间的管理层账号
//            List<CarTransferLogModel> carTransferLogModelList = carTransferLogRepository.findByStockId(lsh库存表Model.get库存编号());
//            CarTransferLogModel carLog = carTransferLogModelList.get(0);
//            List<PushApprovalWorkFlowModel> list调入 = pushApprovalWorkFlowRepository2.findByPermitAndTypeAndVin(8,
//                    lsh库存表Model.get调入经销商(), flow.getQuotedPriceCodeOrVin());
//            PushApprovalWorkFlowModel flow调入 = list调入.get(0);
//            String content调入 = "您于" + getFormatDate(carLog.getInternalApplyDate()) + "提交的生产号为" +
//                    lsh库存表Model.get生产号() + ",车款为" + lsh车型Model.get车型详细() + "的调车申请于" + new SimpleDateFormat("yyyy年MM月dd日").format(new Date())
//                    + "未通过外部审批,顾客姓名：" + carLog.getCustomName() + ",顾客电话：" + carLog.getCustomTel();
//            Lsh消息Model m4 = LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow调入.getPermit(), flow调入.getUserName(),
//                    "调车调出", content调入, flow.getUserName(), carLog.getCustomTel());
//            List appList = new ArrayList();
//            appList.add(flow调入.getUserName());
//            JPush.sendPushForAndroidAndIos(content调入, content调入,
//                    JsonObjectUtils.getJsonObject("8", "2", flow.getQuotedPriceCodeOrVin(), "",
//                            "", ""),
//                    appList, JPush.Platforms.iMgt);
//            //2、发送消息到调入经销商销售行政，确认审批驳回，“。”
//            String isEmegency = carLog.getIsEmegency();
//            String isEmegencyCn = null;
//            if ("0".equals(isEmegency)) {
//                isEmegencyCn = "紧急";
//            } else {
//                isEmegencyCn = "非紧急";
//            }
//            Lsh消息Model m5 = LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow调入.getPermit(), carLog.getInternalApplyUser(),
//                    "调车调出", content调入, flow.getUserName(), carLog.getCustomTel());
//            //驳回之后修改为“SC/CDO可见”
//            Lsh库存内部可见Model invisiM = lsh库存内部可见Repository.findBystocknumber(lsh库存表Model.get库存编号());
//            if (invisiM != null) {
//                lsh库存内部可见Repository.updateStatusById("SC/CDO可见", invisiM.get库存内部可见编号());
//            }
//        }
//    }

    private void postContractModifyProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus, int entrance) throws Exception {
        postContractModifyAndChangeTicketProcess(list, current_step, approvalStatus, entrance);


        // 首先 需要对 每次合同 审批 通过的 进行  后处理， 将 涉及 后市场的 东西 全部 更新或者 修改
        // 我要确保我拿到的 是 最大的 ， 然后才能去拿到 第二大的（即 上一次的）  中文xxd
        // 找到当前用户的索引
        int i = getCurrentStep(list, current_step);
        PushApprovalWorkFlowModel flow = list.get(i);
        String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();//报价编号

        报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
        getLastMsgToUpdateStatus(quotedPriceCodeOrVin, model报价单表, flow);
    }

    private void postContractModifyAndChangeTicketProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus, int entrance) throws Exception {
        // 找到当前用户的索引
        int i = getCurrentStep(list, current_step);
        PushApprovalWorkFlowModel flow = list.get(i);
        String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();//报价编号

        报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
        顾客记录汇总Model model顾客记录汇总 = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
        if (StringUtils.isNullOrBlank(model顾客记录汇总.get顾客姓名())) {
            model顾客记录汇总.set顾客姓名("无");
        }
        if (StringUtils.isNullOrBlank(model顾客记录汇总.get电话号码())) {
            model顾客记录汇总.set电话号码("无");
        }
        //审批通过
        if ("1".equals(approvalStatus)) {
            //1、报价订单表：订单状态=合同C
            // 报价订单表Model model报价订单表 = repository报价订单表.findOne(model报价单表.get订单编号());
            if (12 == flow.getType()) {
                //repository报价订单表.updateOrderStatusById(model报价单表.get订单编号(), "开票C");

                if (model报价单表.get交车() == null) {
                    logger.error("此换票没有交车！报价编号：" + model报价单表.get报价编号());
                }
                报价交车表Model model报价交车表 = repository报价交车表.findOne(model报价单表.get交车());
                if (model报价交车表 == null) {
                    logger.error("此换票没有交车！报价编号：" + model报价单表.get报价编号());
                }
                model报价交车表.set换票时间(DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date()));
                repository报价交车表.save(model报价交车表);
            } else if (10 == flow.getType()) {
                报价订单表Model quotationOrderModel = repository报价订单表.findOne(model报价单表.get订单编号());
                quotationOrderModel.set订单状态("合同C");
                repository报价订单表.save(quotationOrderModel);
            }
            //2、合同签约日期更新
            //报价交车表Model model交车 = repository报价交车表.findOne(model报价单表.get交车());
            java.sql.Date dt = new java.sql.Date(DateFormatUtils.getFormatDate("yyyy-MM-dd", new Date()).getTime());
            repository报价交车表.updateDateById(model报价单表.get交车(), dt);

            //3、更新LSH库存表，更新报价编号
            Lsh库存表Model lsh库存表Model = lsh库存表Repository.findOne(model报价单表.get库存编号());
            lsh库存表Repository.updateQuotedPriceCodeOrVinById(model报价单表.get库存编号(), model报价单表.get报价编号());

            //5、顾客记录汇总：新车销售状态=16
            repository顾客记录汇总.updteNewCarStatusById(model报价单表.get顾客编号(), 16);

            //6、如果订单修改涉及换车，库存表：老的（车辆零售状态-未卖，报价单号-null），新的（车辆零售状态-已卖，更新报价单号）
            //根据报价编号查询初始报价编号，然后根据初始报价编号查询是否还原点=是的数据（即老的报价编号）
            doChangeCarStatus(model报价单表);

            //4.报价单表：是否还原点=是、还原点创建时间=now
            Timestamp ts = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
            repository报价单表.set还原点AndTime(model报价单表.get报价编号(), "是", ts);

            Lsh车型Model lsh车型Model = lsh车型Repository.findOne(model报价单表.get车型编号());
            String carInfo = "";
            if (null != lsh车型Model) {
                carInfo = lsh车型Model.get车型详细();
            }

            //合同审批通过需要向财务发送消息
            SendMsgRoleUtil.sendMsgByFinance(flow.getPermit(),
                    flow.getUserName(),//销售行政
                    MessageType.Type.getName(MessageType.MSG_TYPE_CONTRACT),
                    null,
                    null,
                    MessageContext.getCheckCarSourcePass(flow.getType() == ApprovalWorkFlowEnum.AGREEMENT_UPDATE ? DefaultValueConstant.MESSAGE_HEAD_AGREEMENT_UPDATE : DefaultValueConstant.MESSAGE_HEAD_TICKET_CHANGE,
                            carInfo, model顾客记录汇总.get顾客姓名(), model顾客记录汇总.get电话号码(), entrance),
                    DefaultValueConstant.MESSAGE_SET_TYPE_IN_FANCE,
                    DefaultValueConstant.CHECK_CAR_SOURCE_YES,
                    model顾客记录汇总.get电话号码());

            //极光推送消息
            JsonObject json = JsonObjectUtils.getJsonObject(flow.getType().toString(), approvalStatus,
                    model报价单表.get报价编号().toString(), model顾客记录汇总.get电话号码(),
                    model报价单表.get顾客编号().toString(), model报价单表.get销售顾问());
            //向销售顾问发送消息
            SendMsgRoleUtil.sendMsgBySale(lsh库存表Model,
                    flow,
                    model报价单表,
                    quotedPriceCodeOrVin,
                    model顾客记录汇总,
                    MessageContext.getCheckSourceSalePass(flow.getType() == ApprovalWorkFlowEnum.AGREEMENT_UPDATE ? DefaultValueConstant.MESSAGE_HEAD_AGREEMENT_UPDATE : DefaultValueConstant.MESSAGE_HEAD_TICKET_CHANGE,
                            lsh库存表Model.get生产号(), model顾客记录汇总.get顾客姓名(), model顾客记录汇总.get电话号码(), entrance),
                    entrance,
                    json);

            /*//审批通过发送消息
            String content = "";
            if (flow.getType() == 10) {
                content = "您提交的生产号为" + lsh库存表Model.get生产号() + "的车辆的修改合同审批已经通过,客户姓名" + model顾客记录汇总.get顾客姓名() +
                        "，客户电话" + model顾客记录汇总.get电话号码();
            } else if (flow.getType() == 12) {
                content = "您提交的生产号为" + lsh库存表Model.get生产号() + "的车辆的换票审批已经通过,客户姓名" + model顾客记录汇总.get顾客姓名() +
                        "，客户电话" + model顾客记录汇总.get电话号码();
            }
            LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), model报价单表.get销售顾问(),
                    "合同", content, flow.getUserName(), model顾客记录汇总.get电话号码());
            //推送消息
            //极光推送消息
            JsonObject json = JsonObjectUtils.getJsonObject(flow.getType().toString(), approvalStatus,
                    model报价单表.get报价编号().toString(), model顾客记录汇总.get电话号码(),
                    model报价单表.get顾客编号().toString(), model报价单表.get销售顾问());
            List recList = new ArrayList();
            recList.add(model报价单表.get销售顾问());
            JPush.SendPushITaskForAndroidAndIos(content, content, json, recList);*/

            //如果是换票
            if (12 == flow.getType()) {
                //根据报价编号查找顾客进店点记录（理论上只存在一条）
                顾客进店记录表Model old记录 = null;
                String id = repository顾客进店记录表.findBJBH(quotedPriceCodeOrVin);
                if(id!=null&&!id.trim().equals("")) {
                    old记录 = repository顾客进店记录表.findByQuotedPriceCode(Integer.valueOf(id));
                }
                if (old记录 != null) {
                    //克隆一条记录
                    顾客进店记录表Model cloned记录 = (顾客进店记录表Model) CloneUtils.deepClone(old记录);
                    /*cloned记录.set报价编号(null);
                    cloned记录.set是否零售("-1");*/
                    //意向车型A为原车型
                    List<报价单表Model> model报价单表OldList = repository报价单表.getListByInitQuoteNumberAnd是否还原点(model报价单表.get初始报价单号());
                    if (model报价单表OldList.size() > 0) {
                        报价单表Model e = model报价单表OldList.get(0);
                        cloned记录.set意向车型A(e.get车型编号());
                    }
                    /*cloned记录.set到店时间(Time.valueOf(LocalTime.of(03, 00, 00)));
                    cloned记录.set离店时间(Time.valueOf(LocalTime.of(03, 01, 00)));
                    cloned记录.set停留时间(1);
                    cloned记录.set客户级别("无评级:已经订单或交车");
                    cloned记录.set到店目的("办手续");*/
                    TrafficLogUtils.updateTrafficLogModel(cloned记录,5);
                    repository顾客进店记录表.save(cloned记录);

                    //更新换车之后进店记录的是否零售=是
                    repository顾客进店记录表.update是否零售ById(old记录.get进店编号(), "是");
                }
            }else if (10 == flow.getType()) {
                顾客进店记录表Model model顾客进店记录表 = null;
                String id = repository顾客进店记录表.findBJBH(quotedPriceCodeOrVin);
                if(id!=null&&!id.trim().equals("")) {
                    model顾客进店记录表 = repository顾客进店记录表.findOneByQuotedPriceCode(
                            Integer.valueOf(id));
                }
                String nowDay = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
                if (model顾客进店记录表 == null||!nowDay.equals(new SimpleDateFormat("yyyy-MM-dd").format(model顾客进店记录表.get进店日期()))) {
                    logger.debug("改合同没有今日进店记录！报价编号:" + quotedPriceCodeOrVin);
                } else {
                    /*model顾客进店记录表.set到店目的("办手续");
                    model顾客进店记录表.set客户级别("无评级:已经订单或交车");*/
                    TrafficLogUtils.updateTrafficLogModel(model顾客进店记录表,6);
                    repository顾客进店记录表.save(model顾客进店记录表);
                }
            }
            //修改保险金融状态和新增日志
            changeStatusAfterApproved(model报价单表, flow);

            // 判断车型是否改变，及相关处理
            // 合同修改
            if (ApprovalWorkFlowEnum.AGREEMENT_UPDATE == flow.getType()) {
                this.updateOldOrNewRecord(model报价单表,ApprovalWorkFlowEnum.AGREEMENT_UPDATE);
            }
            // 换票
            else if (ApprovalWorkFlowEnum.TICKET_CHANG == flow.getType()) {
                this.updateOldOrNewRecord(model报价单表,ApprovalWorkFlowEnum.TICKET_CHANG);
            }

            // 触发第三方精品调用确认维护流程
            // 合同修改
            if (ApprovalWorkFlowEnum.AGREEMENT_UPDATE == flow.getType()) {
               this.thirdBoutiqueCallMaintain(ApprovalWorkFlowEnum.AGREEMENT_UPDATE,model报价单表);
            }
            // 换票
            else if (ApprovalWorkFlowEnum.TICKET_CHANG == flow.getType()) {
                this.thirdBoutiqueCallMaintain(ApprovalWorkFlowEnum.TICKET_CHANG,model报价单表);
            }

            // 新财务功能，需修改财务的收款状态和开票状态
                // 合同修改
            if (ApprovalWorkFlowEnum.AGREEMENT_UPDATE == flow.getType()) {
                logger.info("修改财务状态-合同修改阶段。报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
                ResultData result = financeReceivablesService.updateFinanceReceivablesStatus(model报价单表.get初始报价单号(),FinanceConstant.RECEIVABLES_NOT_COMPLETE);
                if (result == null || (result != null && !"true".equalsIgnoreCase(result.getResult()))) {
                    logger.error("修改财务状态-合同修改阶段：修改收款状态失败！报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
                }
            }
                // 换票
            else if (ApprovalWorkFlowEnum.TICKET_CHANG == flow.getType()) {
                logger.info("修改财务状态-换票阶段。报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
                ResultData result1 = financeReceivablesService.updateFinanceReceivablesStatus(model报价单表.get初始报价单号(),FinanceConstant.RECEIVABLES_NOT_COMPLETE);
                if (result1 == null || (result1 != null && !"true".equalsIgnoreCase(result1.getResult()))) {
                    logger.error("修改财务状态-换票阶段：修改收款状态失败！报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
                }
                ResultData result2 = financeReceivablesService.updateFinanceInvoiceStatus(model报价单表.get初始报价单号(),FinanceConstant.INVOICE_NOT_COMPLETE);
                if (result2 == null || (result2 != null && !"true".equalsIgnoreCase(result2.getResult()))) {
                    logger.error("修改财务状态-换票阶段：修改开票状态失败！报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
                }
            }

            // 调用老财务的出入账确认或者换票确认逻辑
            if (ApprovalWorkFlowEnum.AGREEMENT_UPDATE == flow.getType()) { // 合同修改,出入账逻辑
                setService.updateNewCarSaleMoneyForNewFinance(model报价单表.get报价编号(),model报价单表.get销售顾问(),model报价单表.get许可());
            } else if (ApprovalWorkFlowEnum.TICKET_CHANG == flow.getType()) { // 换票，确认逻辑
                SetService.InvoicesState invoicesState = new SetService.InvoicesState();
                invoicesState.VIN = lsh库存表Model.get车架号();
                invoicesState.remark = "";
                invoicesState.invoiceDate = "";
                setService.updateInvoicesStateH(invoicesState,null);
            }


        } else if ("2".equals(approvalStatus)) {
            //审批驳回
//            if (12 == flow.getType()) {//            }
            Lsh库存表Model lsh库存表Model = lsh库存表Repository.findOne(model报价单表.get库存编号());

            //订单状态改为订单驳回(订单R)
            repository报价订单表.updateOrderStatusById(model报价单表.get订单编号(), "合同R");

            // 1、如果涉及换车，库存表：老的（保持不变），新的（车辆零售状态-未卖，报价单号-null）
            if (model报价单表.get初始报价单号() != null) {
                List<报价单表Model> model报价单表OldList = repository报价单表.getListByInitQuoteNumberAnd是否还原点(model报价单表.get初始报价单号());
                //判断是否有换车，找到还原点=是的报价单表的库存编号，与当前的库存编号是否一致
                if (model报价单表OldList.size() > 0) {
                    报价单表Model model报价单表Old = model报价单表OldList.get(0);
                    if (!model报价单表.get库存编号().equals(model报价单表Old.get库存编号())) { //涉及到换车或者从意向订单到订单，需要更新最新挂车的状态为未卖
                        lsh库存表Repository.updateLshStoreStatusById(model报价单表.get库存编号());
                    }
                }
            }

            /* removed by tony at 2017-03-30
            lsh库存表Model.set车辆零售状态("未卖");
            lsh库存表Model.set报价编号(null);
            lsh库存表Repository.save(lsh库存表Model);
            */
            // 2、将报价单表中是否还原点之前的所有报价记录，是否驳回=是，驳回时间=now()

            rollBackOrderData(model报价单表);

            //发送消息
            String content = "";
            if (flow.getType() == 10) {
                content = "您提交的生产号为" + lsh库存表Model.get生产号() + "的车辆的修改合同审批被驳回,客户姓名：" + model顾客记录汇总.get顾客姓名() +
                        "，客户电话：" + model顾客记录汇总.get电话号码();
            } else if (flow.getType() == 12) {
                content = "您提交的生产号为" + lsh库存表Model.get生产号() + "的车辆的换票审批被驳回,客户姓名：" + model顾客记录汇总.get顾客姓名() +
                        "，客户电话：" + model顾客记录汇总.get电话号码();
            }
            LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), lsh库存表Model.get申请销售顾问(),
                    "合同", content, flow.getUserName(), model顾客记录汇总.get电话号码());

            //极光推送消息
            JsonObject json = JsonObjectUtils.getJsonObject(flow.getType().toString(), approvalStatus,
                    model报价单表.get报价编号().toString(), model顾客记录汇总.get电话号码(),
                    model报价单表.get顾客编号().toString(), model报价单表.get销售顾问());
            List recList = new ArrayList();
            recList.add(model报价单表.get销售顾问());
            JPush.SendPushITaskForAndroidAndIos(content, content, json, recList);
        }
    }

    //回滚数据
    private void rollBackOrderData(String initQuo) {
        //initQuo:初始报价编号
        Timestamp ts = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
        List<报价单表Model> oldList = repository报价单表.getListByInitQuoteNumberAnd是否还原点(initQuo);
        if (oldList.size() > 0) {//还原点  则更改还原点第一条
            报价单表Model o = oldList.get(0);
            //更新还原点之前的数据
            repository报价单表.update是否驳回ById(o.get报价编号(), ts, o.get初始报价单号());
        }
        /*else{//非还原点 则修改 最大报价编号一条
            List<报价单表Model> list = repository报价单表.findBy初始报价编号(initQuo);
            报价单表Model o = list.get(0);
            //更新还原点之前的数据
            repository报价单表.update是否驳回ById(o.get报价编号(), ts, o.get初始报价单号());
        }*/

    }

    //回滚数据
    private void rollBackOrderData(报价单表Model 报价单表Model) {
        String initQuo = 报价单表Model.get初始报价单号();
        //initQuo:初始报价编号
        Timestamp ts = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
        List<报价单表Model> oldList = repository报价单表.getListByInitQuoteNumberAnd是否还原点(initQuo);
        if (oldList.size() > 0) {
            报价单表Model o = oldList.get(0);
            // 现订现交流程，订单审批过后，最新报价单就是还原点，如果合同驳回，订单对应的报价单状态没更新，APP会无法正常操作
            List<报价单表Model> qList = repository报价单表.findBy初始报价编号(initQuo);
            报价单表Model qMo = qList.get(0);
            if (qMo.get报价编号().equals(oldList.get(0).get报价编号())) { // 如果还原点对应的就是最新的报价编号
                qMo.set是否驳回("是");
                qMo.set驳回时间(ts);
                qMo.setInvalidReason("2");
                repository报价单表.save(qMo);
            } else { //更新还原点之前的数据
                repository报价单表.update是否驳回ById(o.get报价编号(), ts, o.get初始报价单号());
            }
        } else {
            报价单表Model.set是否驳回("是");
            报价单表Model.set驳回时间(ts);
            报价单表Model.setInvalidReason("2");
            repository报价单表.save(报价单表Model);
        }
    }

    //合同退订
    private void postContractWithdrawProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus, int entrance) {

    }

    //换票
    private void postChangeTicketProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus, int entrance) throws Exception {
        postContractModifyAndChangeTicketProcess(list, current_step, approvalStatus, entrance);
        //涉及到后市场修改，那么需要做更新后市场订单的操作
        //+324——1
        try {
            if (list != null && list.size() > 0) {
                PushApprovalWorkFlowModel flow = list.get(0);
                if (flow != null) {
                    String quotedPriceCodeOrVin = list.get(0).getQuotedPriceCodeOrVin();//报价编号
                    if (!Strings.isNullOrEmpty(quotedPriceCodeOrVin)) {
                        报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
                        getLastMsgToUpdateStatus(quotedPriceCodeOrVin, model报价单表, flow);
                    }
                }
            }
        } catch (Exception e) {
            logger.error("换票部分，后市场更新失败", e);
        }

    }

    //退票
    private void postTicketWithdrawProcess(List<PushApprovalWorkFlowModel> list, String current_step, String approvalStatus, int entrance) throws Exception {
        // 找到当前用户的索引
        int i = getCurrentStep(list, current_step);
        PushApprovalWorkFlowModel flow = list.get(i);
        String quotedPriceCodeOrVin = flow.getQuotedPriceCodeOrVin();//报价编号

        报价单表Model model报价单表 = repository报价单表.findOne(Integer.valueOf(quotedPriceCodeOrVin));
        Timestamp ts = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
        顾客记录汇总Model model顾客记录汇总 = repository顾客记录汇总.findOne(model报价单表.get顾客编号());
        if (StringUtils.isNullOrBlank(model顾客记录汇总.get顾客姓名())) {
            model顾客记录汇总.set顾客姓名("无");
        }
        if (StringUtils.isNullOrBlank(model顾客记录汇总.get电话号码())) {
            model顾客记录汇总.set电话号码("无");
        }
        if ("1".equals(approvalStatus)) {
            //1、报价交车表：退票时间=now 退票财务备注，由财务填写 交车日期=null
            if (model报价单表.get交车() == null) {
                logger.error("此换票没有交车！报价编号：" + model报价单表.get报价编号());
            }
            报价交车表Model model报价交车表 = repository报价交车表.findOne(model报价单表.get交车());
            if (model报价交车表 == null) {
                logger.error("此换票没有交车！报价编号：" + model报价单表.get报价编号());
            }
            model报价交车表.set退票时间(ts);
            model报价交车表.set交车日期(null);
            repository报价交车表.save(model报价交车表);

            //2、顾客进店记录表：到店目的=办手续，是否零售=-1
            顾客进店记录表Model model顾客进店记录表 = null;
            String id = repository顾客进店记录表.findBJBH(quotedPriceCodeOrVin);
            if(id!=null&&!id.trim().equals("")) {
                model顾客进店记录表 = repository顾客进店记录表.findOneByQuotedPriceCode(
                        Integer.valueOf(id));
            }
            String nowDay = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
            if (model顾客进店记录表 == null||!nowDay.equals(new SimpleDateFormat("yyyy-MM-dd").format(model顾客进店记录表.get进店日期()))) {
                logger.error("改顾客没有进店记录！报价编号:" + quotedPriceCodeOrVin);
            } else {
                /*model顾客进店记录表.set到店目的("办手续");
                model顾客进店记录表.set是否零售("-1");
                model顾客进店记录表.set客户级别("无评级:已经订单或交车");*/
                TrafficLogUtils.updateTrafficLogModel(model顾客进店记录表,7);
                repository顾客进店记录表.save(model顾客进店记录表);
            }

            //3、顾客记录汇总：新车销售状态=8（新车战败）on 顾客编号
            repository顾客记录汇总.updteNewCarStatusById(model报价单表.get顾客编号(), 8);


            //4、顾客订单记录：状态=交车后退车，on 顾客编号，车型，销售顾问
            repository顾客订单记录.updateStatusByCustIdAndCarId(model报价单表.get顾客编号(), model报价单表.get交车(),
                    model报价单表.get销售顾问());

            //5、lsh库存表：复制原有车辆，生成新的虚拟车，原有车的车辆零售状态=未卖，报价编号=null
            //5.1 复制库存记录A（原纪录），产生记录B
            Lsh库存表Model lsh库存表Model = lsh库存表Repository.findOne(model报价单表.get库存编号());
//            Lsh库存表Model newRecord = (Lsh库存表Model) CloneUtils.deepClone(lsh库存表Model);

            //5.2 更新记录A的库存状态为"未卖",报价编号设置为空, remove to  SetServiceImpl:updateInvoicesStateT
            //lsh库存表Repository.updateLshStoreStatusById(model报价单表.get库存编号());

            //5.3 插入记录B；更新B的车架号VIN为：xxxxxyyyyyyyy,xxxx=virtua_stock的value值,
            // yyyyyyyy表示库存编号+1补成8位
//            newRecord.set库存编号(null);
//            newRecord.set车架号(null);
//            newRecord.set生产号(null);
//            Lsh库存表Model returnNewRecord = lsh库存表Repository.save(newRecord);
//            VirtualStockModel virtualStockModel = virtualStockModelRepository.findAll().get(0);
//            String pref = virtualStockModel.getValue();
//            String ids = String.valueOf(returnNewRecord.get库存编号() + 1);
//            String str = "00000000";
//            String suf = str.substring(0, 8 - ids.length()) + ids;
//            String vin = pref + suf;
//            lsh库存表Repository.updateLshStoreVinById(returnNewRecord.get库存编号(), vin);

            //6、报价单表：库存编号=虚拟车的库存编号，是否还原点=是，还原点创建时间=now
//            repository报价单表.set还原点And库存编号AndTime(model报价单表.get报价编号(), "是", ts, returnNewRecord.get库存编号());

            //7、报价订单表：订单状态=退票C
            //repository报价订单表.updateOrderStatusById(model报价单表.get订单编号(), "退票C");

            //9、修改金融保险状态和新增日志
            changeStatusAfterWithdrawApproved(model报价单表, flow);

            //9、推送
            String content = "您提交的生产号为" + lsh库存表Model.get生产号() + "的车辆的退票审批已经通过,客户姓名：" + model顾客记录汇总.get顾客姓名() +
                    "，客户电话：" + model顾客记录汇总.get电话号码();
            LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), model报价单表.get销售顾问(),
                    "合同", content, flow.getUserName(), model顾客记录汇总.get电话号码());

            //极光推送消息
            JsonObject json = JsonObjectUtils.getJsonObject(flow.getType().toString(), approvalStatus,
                    model报价单表.get报价编号().toString(), model顾客记录汇总.get电话号码(),
                    model报价单表.get顾客编号().toString(), model报价单表.get销售顾问());
            List recList = new ArrayList();
            recList.add(model报价单表.get销售顾问());
            JPush.SendPushITaskForAndroidAndIos(content, content, json, recList);

            // 设置合同失效日期
            this.updateOldOrNewRecord(model报价单表,ApprovalWorkFlowEnum.TICKET_RETREAT);

            // 触发第三方精品调用确认维护流程
            this.thirdBoutiqueCallMaintain(ApprovalWorkFlowEnum.TICKET_RETREAT,model报价单表);

            // 新财务需求，修改收款状态和开票状态
            logger.info("修改财务状态-退票阶段。报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
            ResultData result1 = financeReceivablesService.updateFinanceReceivablesStatus(model报价单表.get初始报价单号(),FinanceConstant.RECEIVABLES_NOT_COMPLETE);
            if (null == result1 || (null != result1 && !"true".equalsIgnoreCase(result1.getResult()))) {
                logger.error("修改财务状态-退票阶段：修改收款状态失败！报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
            }
            ResultData result2 = financeReceivablesService.updateFinanceInvoiceStatus(model报价单表.get初始报价单号(),FinanceConstant.INVOICE_NOT_COMPLETE);
            if (null == result2 || (null != result2 && !"true".equalsIgnoreCase(result2.getResult()))) {
                logger.error("修改财务状态-退票阶段：修改开票状态失败！报价编号：{}，许可：{}",model报价单表.get报价编号(),model报价单表.get许可());
            }

            // 调用老财务功能的退票确认逻辑
            SetService.InvoicesState invoicesState = new SetService.InvoicesState();
            invoicesState.VIN = lsh库存表Model.get车架号();
            invoicesState.invoiceDate = "";
            invoicesState.remark = "";
            logger.info("调用老财务确认逻辑-退票确认：车架号：{}，许可：{}",lsh库存表Model.get车架号(),model报价单表.get许可());
            boolean result = setService.updateInvoicesStateT(invoicesState,null);
            if (!result) {
                logger.error("调用老财务确认逻辑-退票确认,失败！车架号：{}，许可：{}",lsh库存表Model.get车架号(),model报价单表.get许可());
            }

        } else if ("2".equals(approvalStatus)) {
            Lsh库存表Model lsh库存表Model = lsh库存表Repository.findOne(model报价单表.get库存编号());
            //1、将报价单表中是否还原点之前的所有报价记录，是否驳回=是，驳回时间=now
            rollBackOrderData(model报价单表);
            //repository报价订单表.updateOrderStatusById(model报价单表.get订单编号(), "开票C");

            //订单状态改为订单驳回(订单R)
            repository报价订单表.updateOrderStatusById(model报价单表.get订单编号(), "退票R");

            String content = "您提交的生产号为" + lsh库存表Model.get生产号() + "的车辆的退票审批已被驳回,客户姓名：" + model顾客记录汇总.get顾客姓名() +
                    "，客户电话：" + model顾客记录汇总.get电话号码() + ",原因" + flow.getRemark();
            LshMsgUtils.getLshMsg(flow.getPermit(), flow.getUserName(), flow.getPermit(), model报价单表.get销售顾问(),
                    "合同", content, flow.getUserName(), model顾客记录汇总.get电话号码());

            //极光推送消息
            JsonObject json = JsonObjectUtils.getJsonObject(flow.getType().toString(), approvalStatus,
                    model报价单表.get报价编号().toString(), model顾客记录汇总.get电话号码(),
                    model报价单表.get顾客编号().toString(), model报价单表.get销售顾问());
            List recList = new ArrayList();
            recList.add(model报价单表.get销售顾问());
            JPush.SendPushITaskForAndroidAndIos(content, content, json, recList);
            //2、如果涉及换车，库存表：老的（保持不变），新的（车辆零售状态-未卖，报价单号-null）
        }
    }

    private String getFormatDate(java.sql.Date dt) {
        return new SimpleDateFormat("yyyy年MM月dd日").format(dt);
    }

/*
    public Lsh消息Model getLshMsg(String sendPermit, String sendUser, String recPermit, String recUser, String msgType, String content,
                                String updateUser, String cellNumber) {
        Timestamp ts = DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date());
        Date dt = DateFormatUtils.getFormatDate("yyyy-MM-dd", new Date());
        Lsh消息Model l = new Lsh消息Model();
        l.set发送人(sendUser);
        l.set发送许可(sendPermit);
        l.set接收许可(recPermit);
        l.set接收人(recUser);
        l.set消息分类(msgType);
        l.set消息内容(content);
        l.set是否删除("否");
        l.set更新账号(updateUser);
        l.set消息创建时间(ts);
        l.set更新时间(ts);
        l.set电话号码(cellNumber);
        return lsh消息Repository.save(l);
    }
*/

    /**
     * 获取订单审批list
     */
    @Override
    public PageData getOrderApprovalList(GetApprovalListRequest reqeust) {

//        PageData list = this.pushApprovalWorkFlowRepository.getOrderApprovalList(reqeust.getPageSize(),
//                reqeust.getPageIndex(), reqeust.type, reqeust.permit, reqeust.userName, reqeust);
//        if (reqeust.type.contains("8") || reqeust.type.contains("9")) {
//            for (Object data : list.getData()) {
//                Map map = (Map) data;
//                //找到此车辆的调车审批记录
//                String vin = (String) map.get("车架号");
//                List<PushApprovalWorkFlowModel> hisRecList = pushApprovalWorkFlowRepository2.getFlowByQuo(vin);
//                for (PushApprovalWorkFlowModel p : hisRecList) {
//                    if ("2".equals(p.getApprovalStatus())) {
//                        map.put("调车状态", "被驳回");
//                    }
//                }
//            }
//        }
        return this.pushApprovalWorkFlowRepository.getOrderApprovalList(reqeust.getPageSize(),
                reqeust.getPageIndex(), reqeust.type, reqeust.permit, reqeust.userName, reqeust);
    }

    @Override
    public List getCarTypeList(GetApprovalListRequest reqeust) {
        return this.pushApprovalWorkFlowRepository.getCarTypeList(reqeust);
    }


    /**
     * 获取snp
     */
    @Override
    public List getSNP(getSNPRequest request) {
        List<Map<String, String>> list = new ArrayList<>();
        Map<String, String> map = new HashMap<>();
        Integer type = 0;
        try {
            Boolean needCal; // 是否需要计算的flag
            // 判断该报价编号对应的审批流中是否已经保存了SNP历史
            // 找到报价编号对应的审批流
            List<PushApprovalWorkFlowModel> workFlowList = pushApprovalWorkFlowRepository2.getFlowByQuo(request.quotedPriceCode);
            if (workFlowList == null || workFlowList.size() == 0) { // 找不到对应的审批记录，需要计算
                needCal = true;
            } else { // 找到审批流
                type = workFlowList.get(0).getType();
                if (ApprovalUtils.isContractType(type)) { // 合同类审批时
                    String hisSnp = workFlowList.get(0).getHisSnp();
                    if (hisSnp == null) { // 历史数据中没有保存SNP，需要计算
                        needCal = true;
                    } else {
                        String[] tmp = hisSnp.split("_");
                        map.put("numerator", tmp[0]);
                        map.put("denominator", tmp[1]);
                        map.put("result", tmp[2]);
                        list.add(map);
                        needCal = false;
                    }
                } else { // 非合同类审批，需要计算
                    needCal = true;
                }
            }
            if (needCal) {
                // 合同类审批，且已经生成对应的审批流，且返回的SNP中数据合理时，将计算后的数据保存在his_snp字段中，用_分隔分子分母及结果
                List tmpList = pushApprovalWorkFlowRepository.getSNP(request.carCode, request.apperanceCode, request.quotedPriceCode);
                if (ApprovalUtils.isContractType(type) && workFlowList != null && tmpList.size() != 0) { // 合同类审批，且有结果时
                    // 获取审批提交日期
                    String strDate = workFlowList.get(0).getTranscationCode();
                    strDate = strDate.substring(strDate.length() - 19, strDate.length() - 9).replace("/", "-");
                    // 只有当天提交的合同才会写入SNP（历史合同的SNP已经无法重现）
                    if (LocalDate.parse(strDate).equals(LocalDate.now())) {
                        Map m = (Map) tmpList.get(0);
                        workFlowList.get(0).setHisSnp(m.get("numerator") + "_" + m.get("denominator") + "_" + m.get("result"));
                    }
                }
                return tmpList;
            } else {
                return list;
            }
        } catch (Exception e) {
            logger.error("获取SNP异常");
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            map.put("numerator", "0");
            map.put("denominator", "0");
            map.put("result", "0");
            list.add(map);
            return list;
        }
    }

    /**
     * 获取GP
     */
    @Override
    public List<Map> getGP(String dealer, Integer quoNum) {
        return pushApprovalWorkFlowRepository.getGP(dealer, quoNum);
    }

    /**
     * 合同审批时获取GP4.5
     */
    @Override
    public BigDecimal getGp4d5(Integer qNum) {
        List list = this.pushApprovalWorkFlowRepository.getGp4d5(qNum);
        Double gp4d5 = (Double) ((Map) (list.get(0))).get("gp4d5");
        logger.info("报价单号" + qNum + "对应的gp4.5为" + gp4d5);
        return new BigDecimal(gp4d5);
    }

    /**
     * 顾客重新分配
     */
    @Override
    public Map getAssign(String sex, String phone, String permit) {
        Map map = Maps.newHashMap();
        顾客记录汇总Model model顾客 = repository顾客记录汇总.findOneCus(phone, permit);
        List<用户Model> list销售 = repository用户.findAllSaleMan(permit);
        用户Model model用户 = null;
        if (model顾客 != null) {
            model用户 = repository用户.findByCode(model顾客.get所属销售顾问());
        }
        map.put("list销售", list销售);
        map.put("model顾客", model顾客);
        map.put("model用户", model用户);
        return map;
    }

    @Transactional
    public boolean updateAssignById(String name, String id) {
        try {
            int ids = Integer.valueOf(id);
            //repository顾客记录汇总.updateAssignById(ids,name);
            顾客记录汇总Model model = repository顾客记录汇总.findOne(ids);

            CustomReassignLogModel log = new CustomReassignLogModel();
            log.setCustomCode(model.get顾客编号());
            log.setPreAssignSc(model.get所属销售顾问());
            Timestamp tsTime = Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            log.setReassignDatetime(tsTime);
            customReassignLogRepository.save(log);

            model.set销售顾问(name);
            model.set所属销售顾问(name);
            repository顾客记录汇总.save(model);

            return true;
        } catch (Exception e) {
            logger.error("系统异常。", e);
            return false;
        }
    }

    /**
     * 资源释放
     */
    @Override
    public PageData getRelease(String permit, GetReleaseRequest request) {
        return pushApprovalWorkFlowRepository.getRelease(request.getPageSize(), request.getPageIndex(), request.permit);
    }

    /**
     * 保存延长资源锁定
     */
    @Override
    @Transactional
    public boolean updateReleaseEndDate(UpdateReleaseEndDateRequest req) {
        try {
            repository报价订单表.updateReleaseEndDate(Integer.valueOf(req.orderId), Integer.valueOf(req.newReleaseEndDay));
            return true;
        } catch (Exception e) {
            logger.error("系统异常。", e);
            return false;
        }
    }

    /**
     * 保存释放的后续操作
     */
    @Override
    @Transactional
    public Map updateReleaseHandle(String username, UpdateReleaseHandle req) {
        if (logger.isDebugEnabled()) {
            logger.debug("username={}, req={}", username, JsonObjectUtils.writeAsJson(req));
        }

        Map<String, String> map = Maps.newHashMap();
        try {
            Integer storeId = Integer.valueOf(req.storeId);//库存编号

            // 1:根据库存编号查询LSH库存表，获得真实车
            Lsh库存表Model oldRecord = lsh库存表Repository.findOne(storeId);

            // 判断此车的销售状态
            报价单表Model quoteModel = repository报价单表.findOne(oldRecord.get报价编号());
            顾客记录汇总Model customModel = 顾客记录汇总Repository.findCusByCustomerID(quoteModel.get顾客编号());
            Integer carType = customModel.get新车销售状态();
            // 如果在全款前，此车可以释放
            if (carType < 15) {
                Integer msgQuotedCode = 0;
                // 2:克隆真实车，产生虚拟车
                Lsh库存表Model newRecord = (Lsh库存表Model) CloneUtils.deepClone(oldRecord);
                // 3:更新真实车的库存状态为"未卖", 报价编号设置为空
                lsh库存表Repository.updateLshStoreStatusById(storeId);

                // 4:添加虚拟车到库存表
                // 计算虚拟生产号与虚拟车架号
                VirtualStockModel virtualStockModel = virtualStockModelRepository.findAll().get(0);
                String pre = virtualStockModel.getValue();
                // 取出现有虚拟库存号 + 1作为新的虚拟车架号，并更新原表
                String value = virtualStockModel.getId() + 1 + "";
                virtualStockModelRepository.setNewVirtualStockCode();
                // 计算虚拟库存车架号及生产号
                String suf = "00000000".substring(0, 8 - value.length()) + value;
                String proNumAndVin = pre + suf;

                newRecord.set库存编号(null);
                newRecord.set车架号(proNumAndVin);
                newRecord.set生产号(proNumAndVin);
                newRecord.set车辆零售状态("未卖");
                newRecord.setNbi车辆状态("非本月待批发");
                newRecord.set外部可见级别("外部不可见");
                Lsh库存表Model returnNewRecord = lsh库存表Repository.save(newRecord);

                // 更新虚拟车内部可见级别
                Lsh库存内部可见Model lsh库存内部可见Model = lsh库存内部可见Repository.findBystocknumber(storeId);
                // 若对应的内部可见数据不存在，则新建
                if (lsh库存内部可见Model == null) {
                    lsh库存内部可见Model = new Lsh库存内部可见Model();
                    lsh库存内部可见Model.set库存编号(oldRecord.get库存编号());
                }
                lsh库存内部可见Model.set内部可见角色("SC/CDO不可见");
                lsh库存内部可见Model.set更新账号(username);
                lsh库存内部可见Model.set更新时间(new Timestamp(System.currentTimeMillis()));
                lsh库存内部可见Repository.save(lsh库存内部可见Model);

                // 朱思捷的需求    -- 20161206 byDF
                // 6:根据这条记录的"初始报价单号"查询报价单表,获取到List报价编号，并倒序排序
                // 从第一条开始，找到第一条“是否还原点”为“是”的记录，将此记录到第一条记录的库存编号更新
                // PS：其实虚拟车的报价编号，就是“是否还原点”为“是”的记录，这是审批后处理正常进行的情况
                // 这里重新判断，是为了防止后处理异常而进行了错误的操作
                // 如果没有满足条件的记录，全部改掉
                List<报价单表Model> list = repository报价单表.getListByInitQuoteNumber(quoteModel.get初始报价单号());
                int i = 0;
                for (; i < list.size(); i++) {
                    报价单表Model m = list.get(i);
                    if ("是".equals(m.get是否还原点())) {
                        // 消息的报价编号，是否还原点为是
                        msgQuotedCode = m.get报价编号();
                        for (int j = i; j >= 0; j--) {
                            报价单表Model n = list.get(j);
                            n.set库存编号(returnNewRecord.get库存编号());
                        }
                        repository报价单表.save(list);
                        break;
                    }
                }
                // 如果list中没有”是否还原点“为”是“的记录，将list中全部记录的库存编号改为虚拟车
                if (i == list.size()) {
                    for (报价单表Model m : list) {
                        m.set库存编号(returnNewRecord.get库存编号());
                    }
                    // 所有还原点都是否，取最大的报价编号
                    msgQuotedCode = list.get(0).get报价编号();
                    repository报价单表.save(list);
                }

                // 资源释放要发送消息，获取信息如顾客姓名，车辆信息等
                List<Map> releaseInfo = pushApprovalWorkFlowRepository.getInfo4ManualRelease(msgQuotedCode);
                if (releaseInfo != null && !releaseInfo.isEmpty()) {
                    releaseInfo.get(0).put("车架号", oldRecord.get车架号());
                    Map releaseCar = releaseInfo.get(0);
                    sendMsg(releaseCar, "您的车辆资源已经释放");
                }
                map.put("result", "true");
                map.put("message", "释放成功");
            } else {
                map.put("result", "false");
                map.put("message", "该车已进入付款交车流程，不允许释放");
            }
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("资源释放异常", e);
            map.put("state", "false");
            map.put("message", "系统原因释放失败");
        }
        return map;
    }

    private void sendMsg(Map map, String msgPref) {
        if(map == null){
            logger.warn("Parameter map is null.");
            return;
        }

        String content = msgPref + ",车款:" + map.get("车型详细") + ",车架号:" + map.get("车架号") + ",顾客姓名:"
                + map.get("顾客姓名");
        LshMsgUtils.getLshMsg((String) map.get("许可"), "Admin", null, (String) map.get("销售顾问"), "订单", content,
                (String) map.get("许可"), (String) map.get("电话号码"), null, "报价编号：" + map.get("报价编号"),
                null, null, new Date());
    }

    //虚拟车架号前缀
    public String getVirtualStockPref() {
        if (VIRTUAL_STOCK_PREF == null) {
            List<VirtualStockModel> virtualStockModels = virtualStockModelRepository.findAll();
            if (virtualStockModels != null && virtualStockModels.size() > 0) {
                VIRTUAL_STOCK_PREF = virtualStockModels.get(0).getValue();
            }
            if (VIRTUAL_STOCK_PREF == null) {
                VIRTUAL_STOCK_PREF = "IRISTechnologies";
            }
        }
        return VIRTUAL_STOCK_PREF;
    }

    /**
     * 自动释放的后续操作
     * <p>
     * 资源释放的逻辑完全等同于自动释放的逻辑，参见本类中updateReleaseHandle方法
     */
    @Override
    @Transactional
    public boolean autoReleaseDaily() {
        try {
            List<Map> needReleases = pushApprovalWorkFlowRepository.getAutoRelease(getVirtualStockPref());

            for (Map releaseCar : needReleases) {
                Integer storeId = (Integer) releaseCar.get("库存编号");// 库存编号

                // 1:根据库存编号查询LSH库存表，获得记录A
                Lsh库存表Model oldRecord = lsh库存表Repository.findOne(storeId);

                Lsh库存表Model cloneNewRecord = (Lsh库存表Model) CloneUtils.deepClone(oldRecord);

                // 2:更新记录A的库存状态为"未卖",报价编号设置为空
                lsh库存表Repository.updateLshStoreStatusById(storeId);

                // 3:插入记录B；更新B的车架号VIN为：xxxxxyyyyyyyy,xxxx=virtua_stock的value值,
                // yyyyyyyy表示库存编号+1补成8位
                cloneNewRecord.set库存编号(null);
                cloneNewRecord.set车架号(null);
                cloneNewRecord.set生产号(null);
                Lsh库存表Model newRecord = lsh库存表Repository.save(cloneNewRecord);

                String vin = getVirtualStockPref() + String.format("%08d", newRecord.get库存编号() + 1);
                lsh库存表Repository.updateLshStoreVinById(newRecord.get库存编号(), vin);

                // 5：获取B的报价编号，查询报价单表，获取一条记录
                报价单表Model entity报价单表 = repository报价单表.findOne(newRecord.get报价编号());

                //将手动释放的2步合成一步
                repository报价单表.updateModelByQuoteNumber(newRecord.get库存编号(), newRecord.get报价编号(), entity报价单表.get初始报价单号());

                sendMsg(releaseCar, "您的车辆资源已经释放");
            }
            return true;
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("数据保存异常。", e);
            return false;
        }
    }

    /**
     * 资源释放的提醒
     */
    @Override
    @Transactional
    public boolean sendReleaseNotice() {
        try {
            List<Map> needReleases = pushApprovalWorkFlowRepository.getAutoRelease4Notice(getVirtualStockPref());

            for (Map releaseCar : needReleases) {
                sendMsg(releaseCar, "您的车辆资源即将释放");
            }
            return true;
        } catch (Exception e) {
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.error("系统异常。", e);
            return false;
        }
    }

    /**
     * 重复接待仲裁
     */
    @Override
    public PageData getReArbitrate(String permit, GetReArbitrate req) {
        return pushApprovalWorkFlowRepository.getReArbitrate(req.getPageSize(), req.getPageIndex(), permit);
    }

    @Override
    public PageData getReArbitrateTest(String permit, GetReArbitrate req) {
        if (logger.isDebugEnabled()) {
            logger.debug("permit={}, req={}", permit, JsonObjectUtils.writeAsJson(req));
        }

        // 首先 拿出 所有的 待裁决里面的 (不会有 重复的 ， 只是 销售顾问不同)
        List<顾客记录汇总Model> sucesslist = getCommonListSole(permit);
        /**
         *
         *然后 把 每一个 客户 的  A + （B C ） 拿出来
         *
         * 每一个 Map 放在  List 里面   然后 就是  List 放在 Map 里面
         * */
        List<List<Map>> resultMap = new ArrayList<>();
        if (sucesslist != null && sucesslist.size() > 0) {
            for (int i = 0; i < sucesslist.size(); i++) {
                List<Map> itemlist = new ArrayList();
                顾客记录汇总Model 顾客记录汇总Models = sucesslist.get(i);
                if (顾客记录汇总Models != null) {
                    itemlist = gettransformList(顾客记录汇总Models);
                    resultMap.add(itemlist);
                }
            }
        }

        // 把 [  [{},{}],[{}],[{},{},{}]] 的{}全部 取出来
        List<Map> resultList = new ArrayList<>();
        if (resultMap != null && resultMap.size() > 0) {
            for (int i = 0; i < resultMap.size(); i++) {
                List<Map> mlist = resultMap.get(i);
                for (Map neimap : mlist) {
                    resultList.add(neimap);
                }
            }
        }

        for (int i = 0; i < resultList.size() - 1; i++) {
            for (int j = resultList.size() - 1; j > i; j--) {
                if (resultList.get(j).equals(resultList.get(i))) {
                    resultList.remove(j);
                }
            }
        }

        PageData p = new PageData(resultList, resultMap.size());
        return p;
    }

    private List<Map> gettransformList(顾客记录汇总Model basemodel) {

        // 先根据 主A 里面的 编号 拿出  那些鬼
        List baseList = pushApprovalWorkFlowRepository.getBaseReArbitrateTest(basemodel.get顾客编号());
        List<Map> resultMapList = new ArrayList<>();
        Map baseMap = new HashMap();
        Map resultbaseMap = new HashMap();
        // 根据 许可 电话 查出其他的鬼
        List<顾客待裁决Model> reAriblist = repository顾客待裁决.findReArbitrateBypermitAndTel(basemodel.get许可(), basemodel.get电话号码());
        if (reAriblist != null && reAriblist.size() > 0) {
            for (int i = 0; i < reAriblist.size(); i++) {
                baseMap = (Map) baseList.get(0);
                顾客待裁决Model addMapmodel = reAriblist.get(i);
                if (addMapmodel != null) {
                    用户Model usermodel = 用户repository.findByCode(addMapmodel.get销售顾问());
                    if(usermodel!=null){
                        baseMap.put("销售顾问二", addMapmodel.get销售顾问());
                        baseMap.put("销售顾问姓名二", usermodel.get人员姓名());

                        if (!(baseMap.get("销售顾问一").toString()).equals((baseMap.get("销售顾问二")).toString())) {
                            try {
                                resultbaseMap = (Map) (CloneUtils.deepClone(baseMap));
                                resultMapList.add(resultbaseMap);
                            } catch (Exception e) {
                                logger.error("克隆出错", e);
                            }

                        }
                        baseMap.remove("销售顾问二");
                        baseMap.remove("销售顾问姓名二");
                    }

                }

            }
        }
        return resultMapList;
    }

    /***
     * 拿出 所有 满足条件的  客户拥有者
     * **/
    private List getCommonListSole(String permit) {

        // 这个 拿出来的 是不重复的 用来 查询 出  汇总表中的 拥有者
        List notReAriblist = pushApprovalWorkFlowRepository.getNotReArbitrateTest(permit);
        List<String> permitList = new ArrayList();
        if (notReAriblist != null && notReAriblist.size() > 0) {
            for (int i = 0; i < notReAriblist.size(); i++) {
                Map mapitems = (Map) notReAriblist.get(i);
                String key = mapitems.get("电话号码").toString();
                permitList.add(key);
            }
        } // FIXME: 6/2/2017 notReAriblist的size() == 0的情况
        // 在 去拿出 汇总里面 那个

        List<顾客记录汇总Model> commonlist = new ArrayList<>();
        if (permitList != null && permitList.size() > 0) {
            for (String keys : permitList) {
                顾客记录汇总Model summodel = new 顾客记录汇总Model();
                // 根据 拿到的 许可 和 电话 取出  那个 曾经是  拥有者的 销售顾问
                summodel = 顾客记录汇总Repository.findOneCus(keys, permit);
                if (summodel != null) {
                    commonlist.add(summodel);
                }

            }
        }
        List<顾客记录汇总Model> sucesslist = new ArrayList<>();
        List<顾客记录汇总Model> failalist = new ArrayList<>();
        // 过滤出 失败的 不满足条件的   对于 那些战败去向 不为空的 就是说 这个人战败了的 需要过滤掉
        if (commonlist != null && commonlist.size() > 0) {
            for (int i = 0; i < commonlist.size(); i++) {
                顾客记录汇总Model summodel = commonlist.get(i);
                if (summodel != null
                        && "8".equals(summodel.get新车销售状态())) {
                    failalist.add(summodel);
                } else {
                    // 没有 失败的 就是  剩下的了
                    sucesslist.add(summodel);
                }

            }
        }
        return sucesslist;
    }


    /**
     * 查询仲裁详情
     */
    @Override
    public Map getReArbitrateDetail(String permit, String saleManA, String saleManB, String id) {
        return pushApprovalWorkFlowRepository.getReArbitrateDetail(permit, saleManA, saleManB, id);
    }

    /**
     * 保存仲裁的结果
     */
    @Override
    @Transactional
    public boolean updateReArbitrateDetail(UpdateReArbitrateDetail req) {
        if (logger.isDebugEnabled()) {
            logger.debug("req={}", JsonObjectUtils.writeAsJson(req));
        }
        // 首先传入的  肯定 只能确定 一个 唯一的人
        boolean flag = false;
        try {
            List<顾客待裁决Model> ismodel1 = repository顾客待裁决.findReArbitrateBypermitAndTelAndsoleuser(req.saleMan, req.permit, req.cusTel);
            顾客记录汇总Model ismodel2 = 顾客记录汇总Repository.findOne(Integer.parseInt(req.cusId));// findOneCusAndpermitandusername(req.cusId);
            if (ismodel2 == null) {
                throw new Exception(String.format("找不到顾客记录汇总。id=%", req.cusId));
            }

            Timestamp timestamp = new Timestamp(System.currentTimeMillis());
            if (ismodel1 != null && ismodel1.size() > 0) {
                // 说明 失败者 就是 待裁决 表 里面的  成功者在  汇总表 值给 一个时间
                for (顾客待裁决Model ismodel1item : ismodel1) {
                    ismodel1item.set裁决时间(timestamp);
                    repository顾客待裁决.save(ismodel1item);
                }
                ismodel2.set销售顾问(req.succesMan);
                ismodel2.set所属销售顾问(req.succesMan);
                ismodel2.set裁决时间(timestamp);
                顾客记录汇总Repository.save(ismodel2);
            } else {
                logger.warn(String.format("找不到顾客待裁决。cusName=%s, saleMan=%s, permit=%s, cusTel=%s", req.cusName, req.saleMan, req.permit, req.cusTel));

                // 失败者 在 汇总表中  那么 把  销售顾问 + 所属的 销售 顾问  更改， 并且 把 成功者 在 汇总表 给 一个时间  ，  在  待仲裁中的  成功者 也需要给 一个 时间
                ismodel2.set销售顾问(req.succesMan);
                ismodel2.set所属销售顾问(req.succesMan);
                ismodel2.set裁决时间(timestamp);
                顾客记录汇总Repository.save(ismodel2);

                List<顾客待裁决Model> ismodel3 = repository顾客待裁决.findReArbitrateBypermitAndTelAndsoleuser(req.succesMan, req.permit, req.cusTel);
                if (ismodel3 != null && ismodel3.size() > 0) {
                    for (顾客待裁决Model ismodel3items : ismodel3) {
                        ismodel3items.set裁决时间(timestamp);
                        ismodel3items.set所属销售顾问(req.saleMan);
                        ismodel3items.set销售顾问(req.saleMan);
                        repository顾客待裁决.save(ismodel3items);
                    }
                } else {
                    logger.warn(String.format("找不到顾客待裁决。cusName=%s, saleMan=%s, permit=%s, cusTel=%s", req.cusName, req.succesMan, req.permit, req.cusTel));
                }
            }

            /*
             * 把仲裁历史写入到  仲裁的 log表里面
             * */
            saveCustJudgeLog(req, ismodel1);
            // 仲裁后处理
            flag = ReArbitrateAfterTreatment(req);
        } catch (Exception e) {
            flag = false;
            logger.error("更改仲裁结果失败", e);
        }
        return flag;
    }


    private boolean ReArbitrateAfterTreatment(UpdateReArbitrateDetail req) {
        boolean flag = true;
        try { // 销售顾问+电话号码--》拿到顾客记录汇总里面的顾客编号，根据顾客编号---》报价单表的顾客编号拿到初始报价单号
            // 或者直接 根据电话号码和许可
//            顾客记录汇总Model sucessModel = 顾客记录汇总Repository.findOne(Integer.parseInt(req.cusId));
//            List failSCList = pushApprovalWorkFlowRepository.findNotRepeatReArbByPTel(req.permit, req.cusTel,
//                    sucessModel.get销售顾问(), req.cusId, req.saleMan);

            String customerId= req.cusId;
            List bjdMax= customerInfoRepository.getBjdMax(customerId,"", "否");
            if(bjdMax!=null&&bjdMax.size()>0){
                Map bjdMaxMap= (Map) bjdMax.get(0);
                String csbjdh=null;
                if(bjdMax!=null&&bjdMax.size()>0){
                    csbjdh= bjdMaxMap.get("初始报价单号")+"";
                    String xsgw = req.succesMan;//转移仲裁失败的销售顾问信息
                    for (int i = 0; i < bjdMax.size(); i++) {
                        Map bjdMap= (Map) bjdMax.get(i);
                        Object bjNo=bjdMap.get("报价编号");
                        if(!xsgw.equals("null")&&!csbjdh.equals("null")&& csbjdh!=null){
                            int c= repository报价单表.updateBjdOnXsgw(xsgw,csbjdh);//SET 销售顾问=? WHERE 初始报价单号=？
                            logger.info("更新报价单表："+c);
                        }
                        List list=null;
                        if (bjNo!=null ){
                            list= customerInfoRepository.getUnpaidCar(Integer.parseInt(bjNo.toString()));
                        }else{
                            logger.warn("根据最大顾客编号："+bjNo+"未找到关联数据！");
                        }
                        if(list!=null&&list.size()>0){
                            Map map= (Map) list.get(0);
                            String kcbh= map.get("库存编号")+"";
                            String gkbh= map.get("顾客编号")+"";
                            if(!xsgw.equals("null")&&!gkbh.equals("null")&&!kcbh.equals("null")) {
                                logger.info("销售顾问:"+xsgw+",顾客编号:"+gkbh+",库存编号:"+kcbh);
                                int c2 = repository顾客订单记录.updateGkddInfo(xsgw, Integer.parseInt(gkbh), Integer.parseInt(kcbh));
                                logger.info("更新顾客订单记录表："+c2);
                            }
                        }
                    }
                }
            }else{
                logger.warn("没有找到客户编号的最大报价编号");
            }


           /* List<报价单表Model> resultList = new ArrayList();
            List<Map> updataModelList = new ArrayList<>();
            List<Map> centerModellist = new ArrayList<>();
            for (int i = 0; i < failSCList.size(); i++) {
                Map iteMap = (Map) failSCList.get(i);
                if (iteMap.get("scMan") != null) {
                    String scMan = iteMap.get("scMan").toString();
                    // 根据销售顾问和顾客编号查询出 报价单中的所有未交车的生命周期的报价单
//                    centerModellist = repository报价单表.findByCustomerLimitOne(Integer.parseInt(req.cusId), scMan);
                        centerModellist= customerInfoRepository.getUnpaidCar(Integer.parseInt(req.cusId));
                    if (centerModellist != null && centerModellist.size() > 0) {
                        updataModelList.add(centerModellist.get(0));
                    }
                }
            }
            // 失败者对应的报价单取出来，与交车表做关联，取出未交车的报价单
            if (updataModelList != null && updataModelList.size() > 0) {
                for (Map updateItem : updataModelList) {
                    if (updateItem != null) {
                        String InitQuoteId = updateItem.get("初始报价单号").toString();
                        // 顾客id+失败销售顾问----》初始报价单号，--》 最新的 是否还原=是+ 是否驳回 否 最新的一条
                        List<报价单表Model> InitQuoteIdList = repository报价单表.getListByInitQuoteAnd(InitQuoteId);
                        if (InitQuoteIdList != null && InitQuoteIdList.size() > 0) {
                            报价单表Model InitModel = InitQuoteIdList.get(0);
                            if (InitModel != null) {
                                if (InitModel.get交车() != null && updateItem.get("交车") != null) {
                                    报价交车表Model saleCarModel = repository报价交车表.findby编号(Integer.parseInt(updateItem.get("交车").toString()));
                                    //if (saleCarModel != null && saleCarModel.get交车日期() == null) {
                                    if (saleCarModel.get交车日期() == null) {
                                        //交车日期为空 那么也是没有交车
                                        resultList.add(InitModel);
                                    }else{
                                        jiaochezhixing(resultList); //交车才执行
                                    }
                                } else {
                                    // 如果没有交车，那么就是压根未交车，
                                    resultList.add(InitModel);


                                }
                            }
                        }
                    }
                }
            }*/


          /*  try {
                // 并且将库存信息释放
                if (resultList != null && resultList.size() > 0) {
                    for (报价单表Model items : resultList) {
                        Integer stockid = items.get库存编号();
                        if (stockid != null) {
                            Lsh库存表Model stockmodel = lsh库存表Repository.findOne(stockid);
                            if (stockmodel != null) {
                                stockmodel.set车辆零售状态("未卖");
                                stockmodel.set报价编号(null);
                                lsh库存表Repository.save(stockmodel);
                            }
                        }
                    }
                }
            } catch (Exception e) {
                logger.error(String.format("订单仲裁,修改库存表，释放资源时失败，传入的顾客编号为=%s", req.cusId), e);
            }*/
        } catch (Exception e) {
            logger.error(String.format("订单仲裁失败，传入的顾客编号为=%s", req.cusId), e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            flag = false;
        }

        return flag;
    }
    // 将所有失败销售顾问的报价单且未交车的报价单进行失败后处理，
    public void jiaochezhixing(List<报价单表Model> resultList){
        if (resultList != null && resultList.size() > 0) {
            for (报价单表Model item : resultList) {
                List<报价单表Model> InitQuoteIdList = repository报价单表.findBy初始报价编号(item.get初始报价单号());
                if (InitQuoteIdList != null && InitQuoteIdList.size() > 0) {
                    // 所有失败销售顾问对应的未交车的报价单----》对应的初始报价单号下所有的报价单，统一做驳回处理
                    for (报价单表Model items : InitQuoteIdList) {
                        items.set是否驳回("是");
                        items.set驳回时间(new Timestamp(System.currentTimeMillis()));
                        items.setInvalidReason("1");
                        repository报价单表.save(items);
                    }
                }
            }
        }
    }

    @Transactional
    private void saveCustJudgeLog(UpdateReArbitrateDetail req, List<顾客待裁决Model> ismodel1) {
        CustJudgeLogModel itemscu = new CustJudgeLogModel();
        if (!"".equals(req.cusId) && (req.cusId) != null) {
            itemscu.setCustId(Integer.parseInt(req.cusId));
            if (ismodel1 != null && ismodel1.size() > 0) {
                itemscu.setNewSc(req.saleMan);//  失败者 是  待裁决中的
                itemscu.setOrgSc(req.succesMan);
            } else {
                itemscu.setNewSc(req.succesMan);
                itemscu.setOrgSc(req.saleMan);// 失败者 是  汇总表中的
            }
            itemscu.setFinalSc(req.succesMan);
            itemscu.setUpdatTime(new Timestamp(System.currentTimeMillis()));
            custJudgeLogRespository.save(itemscu);
        }
    }


    @Override
    public List showCarTransferLog(String permit, String VIN) {
        return pushApprovalWorkFlowRepository.showCarTransferLog(permit, VIN);
    }

    @Override
    public ResultData contractFlowCheck(String permit, String quotedPriceNumber, String pStockId) {
        // 报价编号参数检验
        Integer qtdPriceNumber;
        try {
            qtdPriceNumber = Integer.parseInt(quotedPriceNumber);
        } catch (Exception e) {
            logger.error("审批人提醒功能传入报价编号不能转换成整形", e);
            return new ResultData("false", "报价编号非法", null);
        }
        报价单表Model qtdSheetModel = repository报价单表.findOne(qtdPriceNumber);
        if (qtdSheetModel == null) {
            return new ResultData("false", "找不到对应的报价编号", null);
        }
        // 获取全部许可的合同审批流程
        List allSetList = imgtRepository.getContractFlowSetting(0);
        List<Map> list = new ArrayList<>();
        List<Map<String, Object>> reList = new ArrayList<>();
        // 过滤许可，找出本店流程
        for (Object o : allSetList) {
            String allPermit = (String) ((Map) o).get("permit");
            if (allPermit.equals(permit)) {
                list.add((Map) o);
            }
        }
        // 审批流程设置校验
        if (list.size() == 0) {
            return new ResultData("false", "审批流程没有设置", null);
        }
        // 取出字段作为返回记录
        for (Object o : list) {
            Map m = (Map) o;
            Map<String, Object> reTmp = new HashMap<>();
            reTmp.put("人员姓名", m.get("userOrPosition"));
            reTmp.put("审批级别", m.get("审批级别"));
            reList.add(reTmp);
        }

        // 添加角色字段
        String scEmail = qtdSheetModel.get销售顾问();
        List<String> userNameList = new ArrayList<>();
        reList.get(0).put("人员姓名", scEmail); // 一级必定是销售顾问，这里将其邮箱放在一级审批人，才能支持角色审批流程
        for (int i = 0; i < reList.size(); i++) {
            Map<String, Object> map = reList.get(i);
            String userOrPosition = (String) map.get("人员姓名");
            用户Model userModel;
            if (!setService.isRoleName(userOrPosition)) { // 如果存的是组织，将组织转化成具体人名
                if (userOrPosition.contains("财务经理")) { // 如果是财务经理，从本店随便找一个审批
                    List<用户Model> tmpUserList = 用户repository.findBy角色And许可(permit, "财务经理");
                    if (tmpUserList == null || tmpUserList.size() == 0) {
                        return new ResultData("false", "找不到任何财务经理", null);
                    } else {
                        userModel = tmpUserList.get(0);
                    }
                } else {
                    String baseName;
                    if (i == 0) { // 一级审批是角色时，找销售顾问的上级
                        baseName = scEmail;
                    } else { // 其他审批是角色是，取前面审批人的上级
                        baseName = (String) reList.get(i - 1).get("userEmail");
                        int j = i - 1;
                        for (; j >= 0; j--) {
                            String role = 用户repository.findRoleByUsername(baseName);
                            if (role != null && "财务经理".equals(role.trim())) { // 如果baseName是财务经理账号，继续往前找
                                baseName = (String) reList.get(j).get("userEmail");
                            } else { // 非财务经理账号，baseName不处理
                                break;
                            }
                        }
                        if (j == -1) { // 如果在审批人中全是财务经理，用销售顾问账号作为baseName
                            baseName = scEmail;
                        }
                    }
                    // 按用户组织架构获取当前流程用户上级领导
                    userModel = getSuperiorByOrgArchAndUser(userOrPosition, baseName);
                    String role = userOrPosition.split("_")[1];
                    if (userModel == null) {
                        return new ResultData("false", "用户" + baseName + "找不到上级审批角色：" + role + "，请联系销售行政进行设置，用户可能已删除。", null);
                    }
                }
                map.put("角色", userModel.get角色());
                map.put("人员姓名", userModel.get人员姓名());
                // 不需要返回的字段，但需要为找上级作准备
                map.put("userEmail", userModel.get用户名());
            } else { //如果存的是用户
                userNameList.add(userOrPosition);
                map.put("userEmail", userOrPosition);
            }
        }
        List<用户Model> userList = repository用户.findAll(userNameList);
        for (用户Model model : userList) {
            String userEmail = model.get用户名();
            String position = model.get角色();
            for (Map<String, Object> map : reList) {
                String baseUserEmail = (String) map.get("人员姓名");
                if (userEmail.equals(baseUserEmail)) {
                    map.put("角色", position);
                    map.put("人员姓名", model.get人员姓名());
                }
            }
        }

        Lsh车型Model carMo = lsh车型Repository.findOne(qtdSheetModel.get车型编号());
        String carModelStr = carMo.get车型();
        String carDetailStr = carMo.get车型详细();
        String carStr = carMo.get品牌() + "__" + carMo.get级别() + "__" +carModelStr + "__" + carDetailStr;//carMo.get品牌() + "__" + carMo.get级别() + "__" + carMo.get车型();
        Integer needPriCount = reList.size() - 1;
        List<Itask基础设置ModelPK> itaskPkList = new ArrayList<>(needPriCount); // 按审批人级数 - 1取权限
        for (int i = 0; i < needPriCount; i++) {
            Itask基础设置ModelPK pk = new Itask基础设置ModelPK();
            pk.set许可(permit);
            pk.set设置项目(ApprovalUtils.STEP + (i + 1) + "__" + carStr);
            itaskPkList.add(pk);
        }
        List<Itask基础设置Model> itaskModelList = itask基础设置Repository.findAll(itaskPkList);
        Integer priCount = 0; // 有效的权限数量
        for (Itask基础设置Model mo : itaskModelList) {
            if (mo != null) priCount++;
        }
        if (priCount == 0) {
            logger.warn("找不到ITask基础设置数据。itaskPkList={}", JsonObjectUtils.writeAsJson(itaskPkList));
            return new ResultData("false", "该车型暂未设置商务审批政策,禁止提交审核", null);
        }
        if (logger.isDebugEnabled()) {
            logger.debug("ITask基础设置数据。itaskModelList={}", JsonObjectUtils.writeAsJson(itaskModelList));
        }
        // 有可能权限的项目比审批项目数量少，数据不完整
        if (needPriCount > priCount) { // 因为最后一级审批人
            return new ResultData("false", "该车型对应商务政策不完整,禁止提交审核");
        }
        // 获取本单gp4.5
        BigDecimal gp4d5 = ApprovalUtils.getGP4d5(qtdPriceNumber);
        List<Map> resultList = new ArrayList<>();
        for (int i = 0; i < reList.size(); i++) {
            if (i == 0) { // 1级是销售顾问，只有销售顾问进入审批流，且通过
//                resultList.add(reList.get(0));
            } else {
                BigDecimal pri;
                try {
                    pri = new BigDecimal(itaskModelList.get(i - 1).get值());
                } catch (Exception e) {
                    logger.error("系统中权限值非法", e);
                    return new ResultData("false", "系统中权限值非法", null);
                }
                // 是否需要二级审批人处理，由一级审批人的权限，及当前gp4.5决定，所以是和前一级审批人的权限比较
                if (gp4d5.compareTo(pri) < 0) { // 当前gp4.5小于权限值，添加进审批流水
                    resultList.add(reList.get(i));
                } // 否则不参与审批
            }
        }
        if (resultList.size() == 0) { // 如果只有销售顾问在list中，表示不需要审批
            return new ResultData("true", "此报价不需要经过合同审批，是否提交", null);
        }
        // 将结果排序，返回给前台
        for (Object obj : resultList) {
            Map<String, Object> map = (Map) obj;
            String level = (String) map.get("审批级别");
            if ("销售顾问".equals(level)) {
                map.put("order", 1);
            } else if ("一级审批".equals(level)) {
                map.put("order", 2);
            } else if ("二级审批".equals(level)) {
                map.put("order", 3);
            } else if ("三级审批".equals(level)) {
                map.put("order", 4);
            } else if ("四级审批".equals(level)) {
                map.put("order", 5);
            } else if ("五级审批".equals(level)) {
                map.put("order", 6);
            } else if ("六级审批".equals(level)) {
                map.put("order", 7);
            } else if ("七级审批".equals(level)) {
                map.put("order", 8);
            } else if ("八级审批".equals(level)) {
                map.put("order", 9);
            }
        }
        return new ResultData("true", "正常", new PageData(resultList, resultList.size()));
    }

    @Override
    public ResultData contractFlowCheck(String permit, String quotedPriceNumber) {
        return contractFlowCheck(permit, quotedPriceNumber, null);
    }

    @Override
    public ResultData getCurrentApprovalStatus(String quotedPriceNumber) {
        logger.debug("quotedPriceNumber = {}", quotedPriceNumber);
//        // 通过报价编号获取初始报价单号
        报价单表Model 报价单表Model = repository报价单表.findOne(Integer.parseInt(quotedPriceNumber));
        if (报价单表Model == null) return new ResultData("true", "没有报价数据", null);

//        // 通过初始报价单号，找到销售平台报价单生命流程对应的记录，list中报价编号从大到小有序
//        List<报价单表Model> 报价单表ModelList = repository报价单表.getListByInitQuoteNumber(报价单表Model.get初始报价单号());
//        // 根据报价单表ModelList的报价编号，找到生命流程对应的所有最新审批数据
//        List<PushApprovalWorkFlowModel> workFlowModelList = new ArrayList<>();
//        for (int i = 0; i < 报价单表ModelList.size(); i++) {
//            报价单表Model model = 报价单表ModelList.get(i);
//            workFlowModelList = pushApprovalWorkFlowRepository2.getFlowByQuo(model.get报价编号() + "");
//            // 找到的第一个非0大小的list就是
//            if (workFlowModelList.size() != 0) {
//                break;
//            }
//        }
        List<Map> reList = new ArrayList<>();
//        //检测是否有财务订金确认
//        Map mapOrder = getDepositStatus(quotedPriceNumber, 报价单表Model.get许可());
//        if (mapOrder.size() != 0) { // 如果返回车资确认有数据
//            reList.add(mapOrder);
//            return new ResultData("true", "正常", new PageData(reList, reList.size()));
//        }

        List<PushApprovalWorkFlowModel> workFlowModelList = pushApprovalWorkFlowRepository2.getFlowByQuoOrderById(quotedPriceNumber);
        if (workFlowModelList.size() == 0) return new ResultData("true", "未提交审批数据", null);

        // 将当前审批记录按id排序，以便返回审批状态
        workFlowModelList.sort((PushApprovalWorkFlowModel p1, PushApprovalWorkFlowModel p2) -> p1.getId() - p2.getId());

        // 根据审批状态，判断具体显示哪一条提示
        Integer index;
        String statuses = "";
        for (PushApprovalWorkFlowModel model : workFlowModelList) {
            statuses += model.getApprovalStatus();
        }
        // 驳回的流程显示驳回审批人
        if (statuses.contains("2")) {
            index = statuses.indexOf("2");
            // 未完成的流程显示下级审批人
        } else if (statuses.contains("0")) {
            index = statuses.indexOf("0");
            // 通过的流程显示最后一级审批人
        } else {
            index = statuses.lastIndexOf("1");
        }

        // 根据审批状态返回相应的数据信息
        for (int i = 0; i < workFlowModelList.size(); i++) {
            Map<String, String> reMap = new HashMap<>();
            PushApprovalWorkFlowModel pModel = workFlowModelList.get(i);
            if ("2".equals(pModel.getApprovalStatus())) {
                reMap.put("statusCn", "驳回");
                reMap.put("statusEn", "2");
            } else if ("0".equals(pModel.getApprovalStatus())) {
                reMap.put("statusCn", "待审批");
                reMap.put("statusEn", "0");
            } else {
                if ("1".equals(pModel.getApprovalStatus())) {
                    reMap.put("statusCn", "通过");
                    reMap.put("statusEn", "1");
                } else {
                    reMap.put("statusCn", "自动通过");
                    reMap.put("statusEn", "3");
                }
            }
            if (i == index) {
                reMap.put("currentStep", "true");
            } else {
                reMap.put("currentStep", "false");
            }
            String level;
            switch (pModel.getStep()) {
                case "step1":
                    level = "一级批复";
                    break;
                case "step2":
                    level = "二级批复";
                    break;
                case "step3":
                    level = "三级批复";
                    break;
                case "step4":
                    level = "四级批复";
                    break;
                case "step5":
                    level = "五级批复";
                    break;
                case "step6":
                    level = "六级批复";
                    break;
                case "step7":
                    level = "七级批复";
                    break;
                case "step8":
                    level = "八级批复";
                    break;
                case "step9":
                    level = "九级批复";
                    break;
                default:
                    level = "未知级别";
            }
            reMap.put("stepCn", level);
            reMap.put("stepEn", pModel.getStep());
            用户Model uModel = 用户repository.findByCode(pModel.getUserName());
            String reType;
            switch (pModel.getType()) {
                case 1:
                    reType = "订单";
                    break;
                case 2:
                    reType = "意向订单";
                    break;
                case 3:
                    reType = "合同";
                    break;
                case 4:
                    reType = "订单退订";
                    break;
                case 5:
                    reType = "意向订单退订";
                    break;
                case 6:
                    reType = "订单修改";
                    break;
                case 7:
                    reType = "意向订单修改";
                    break;
                case 10:
                    reType = "合同修改";
                    break;
                case 11:
                    reType = "合同退订";
                    break;
                case 12:
                    reType = "换票";
                    break;
                case 13:
                    reType = "退票";
                    break;
                default:
                    reType = "未知类型";
            }
            reMap.put("typeEn", pModel.getType() + "");
            reMap.put("typeCn", reType);
            reMap.put("role", uModel.get角色());
            reMap.put("nameEn", uModel.get用户名());
            reMap.put("nameCn", uModel.get人员姓名());
            reList.add(reMap);

            //为合同通过且是最后一级合同审批时 检测有无车资确认
            if ((ApprovalWorkFlowEnum.AGREEMENT_UPDATE == pModel.getType()
                    || ApprovalWorkFlowEnum.TICKET_CHANG == pModel.getType()
                    || ApprovalWorkFlowEnum.AGREEMENT == pModel.getType()
            ) && ("1".equals(pModel.getApprovalStatus()) || "9".equals(pModel.getApprovalStatus()))
                    && pModel.getId().equals(workFlowModelList.get(workFlowModelList.size() - 1).getId())) {
                Map map = getCheckSourceStatus(quotedPriceNumber, pModel.getPermit(), pModel.getType());
                if (map.size() != 0) { // 如果返回车资确认有数据
                    reList.add(map);
                } // 没数据就不管
            }
        }
        if (ApprovalUtils.isContractType(Integer.parseInt((String) reList.get(0).get(("typeEn"))))) { // 如果是合同审批
            Stack<Map> stack = new Stack<>();
            String typeEn = (String) reList.get(0).get("typeEn"); // 暂存类型En
            String typeCn = (String) reList.get(0).get("typeCn"); // 暂存类型Cn
            List<Map> tmpList = new ArrayList<>();
            for (int i = reList.size() - 2; i >= 0; i--) { // 去掉1级销售顾问
                Map map1 = reList.get(i);
                Map<String, Object> map2 = reList.get(i + 1);
                if (Integer.parseInt((String) map2.get("typeEn")) != 14) { // 当最后一级不是资源确认时，将stepEn往后移一位
                    map2.put("stepEn", map1.get("stepEn"));
                    map2.put("stepCn", map1.get("stepCn"));
                }
                stack.push(map2); // 数据是step4, step3, step2这样的顺序，入栈处理
            }
            while (!stack.isEmpty()) {
                tmpList.add(stack.pop());
            }
            reList = tmpList;
            if (reList.size() == 0) {
                Map<String, String> map = new HashMap<>();
                map.put("statusCn", "通过");
                map.put("statusEn", "");
                map.put("currentStep", "true");
                map.put("stepCn", "无审批");
                map.put("stepEn", "");
                map.put("typeEn", typeEn);
                map.put("typeCn", typeCn);
                map.put("role", "");
                map.put("nameEn", "");
                map.put("nameCn", "");
                List<Map> list = new ArrayList<>();
                list.add(map);
                return new ResultData("true", null, new PageData(list, list.size()));
            }
        }
        return new ResultData("true", "正常", new PageData(reList, reList.size()));
    }

    @Transactional
    public ResultData CancelApproval(getCancalApproval re, String permit, String username) {
        if (logger.isDebugEnabled()) {
            logger.debug("getCancalApproval={}, permit={}, username={}", JsonObjectUtils.writeAsJson(re), permit, username);
        }

        ResultData rd = new ResultData();
        String flag = "true";
        String msg = "撤销成功。";
        Timestamp nowtime = new Timestamp(System.currentTimeMillis());

        if (!Strings.isNullOrEmpty(re.qid) && !Strings.isNullOrEmpty(re.state)) {
            // 获取当前审批流数据按倒叙排序
            List<PushApprovalWorkFlowModel> modelList = pushApprovalWorkFlowRepository2.getFlowByQuoOrderById(re.qid);
            if (modelList != null && modelList.size() > 0) {
                PushApprovalWorkFlowModel itemmodel = modelList.get(0);
                // 如果最后一条审批状态！=0，即有审批记录，不执行操作
                if (!(itemmodel.getApprovalStatus()).equals("0")) {
                    //如果appStatus!=0  那么 直接返回 是 审批已经完成
                    flag = "false";
                    msg = "审批已经完成，无法修改";
                } else {
                    //如果最新的一条 appStatus=0 那么 先 插入到 日志表  再 直接删除 list
                    try {
                        //魅
                        for (int i = 0; i < modelList.size(); i++) {
                            CancelApprovalWorkflowModel insertmodel = new CancelApprovalWorkflowModel();
                            PushApprovalWorkFlowModel oldmmodel = modelList.get(i);
                            insertmodel.setCancelTime(nowtime);
                            insertmodel.setCancelUser(username);

                            insertmodel.setApprovalStatus(oldmmodel.getApprovalStatus());// 11

                            insertmodel.setFlag(oldmmodel.getFlag());
                            insertmodel.setId(oldmmodel.getId());
                            insertmodel.setType(oldmmodel.getType());
                            insertmodel.setPermit(oldmmodel.getPermit());
                            insertmodel.setProcessTime(oldmmodel.getProcessTime());//5

                            insertmodel.setQuotedPriceCodeOrVin(oldmmodel.getQuotedPriceCodeOrVin());
                            insertmodel.setTranscationCode(oldmmodel.getTranscationCode());
                            insertmodel.setStep(oldmmodel.getStep());
                            insertmodel.setRemark(oldmmodel.getRemark());
                            insertmodel.setUserName(oldmmodel.getUserName());//10

                            cancelApprovalWorkflowRepository.save(insertmodel);
                        }
                        // 还需要 发送消息
                        setMsgToApprovalMan(modelList, re, permit, username);

                        pushApprovalWorkFlowRepository2.deleteByQuoId(re.qid);
                    } catch (Exception e) {
                        logger.error("删除审批列表失败", e);
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        flag = "false";
                        msg = "删除审批流程失败。";
                    }
                }
            } else {
                logger.warn("找不到审批流程信息。报价单={}", re.qid);
            }

            // 审批流迁移完毕后处理
            if ("true".equals(flag)) {
                // 报价单标记驳回
                报价单表Model updateModel = repository报价单表.findOne(Integer.parseInt(re.qid));
                updateModel.set是否驳回("是");
                updateModel.set驳回时间(nowtime);
                updateModel.setInvalidReason("3");
                repository报价单表.save(updateModel);

                //订单状态改为订单驳回(订单R)
                报价订单表Model 报价订单 = repository报价订单表.findOne(updateModel.get订单编号());
                String 订单状态 = 报价订单.get订单状态();
                if (logger.isInfoEnabled()) {
                    logger.info("订单({})状态为({})", updateModel.get订单编号(), 订单状态);
                }

                if ("合同O".equalsIgnoreCase(订单状态)) {
                    repository报价订单表.updateOrderStatusById(updateModel.get订单编号(), "合同R");
                } else if ("意向订单".equalsIgnoreCase(订单状态)) {
                    repository报价订单表.updateOrderStatusById(updateModel.get订单编号(), "意向订单R");
                } else if ("订单O".equalsIgnoreCase(订单状态)) {
                    repository报价订单表.updateOrderStatusById(updateModel.get订单编号(), "订单R");
                } else if ("退订".equalsIgnoreCase(订单状态)) {
                    repository报价订单表.updateOrderStatusById(updateModel.get订单编号(), "退订R");
                } else if ("退票".equalsIgnoreCase(订单状态)) {
                    repository报价订单表.updateOrderStatusById(updateModel.get订单编号(), "退票R");
                }

                // 释放库存信息
//                releaseVechile(re.qid, updateModel);
                releaseVechileNew(re.qid, updateModel);
            }
        } else {
            flag = "false";
            msg = "传入参数不完整";
        }

        rd.setResult(flag);
        rd.setMessage(msg);
        return rd;
    }

    /**
     * 撤单后车辆资源释放
     *
     * @param qid
     * @param updateModel
     * @return
     */
    /*
    @Transactional
    private String releaseVechile(String qid, 报价单表Model updateModel) {
        if (logger.isDebugEnabled()) {
            logger.debug("qid={}, updateModel={}", qid, JsonObjectUtils.writeAsJson(updateModel));
        }

        String flag = "";
        try {
            if (updateModel.get库存编号() != null) {
                //获取同一初始报价单号最新的非驳回报价编号
                String ids = pushApprovalWorkFlowRepository.getBugAndLshItask(updateModel.get初始报价单号());
                if (logger.isDebugEnabled()) {
                    logger.debug("ids={}", ids);
                }

                if (ids.equals("0")) {
                    // 没有上一条数据则更新
                    Lsh库存表Model lmodel = lsh库存表Repository.findOne(updateModel.get库存编号());
                    if (lmodel != null) {
                        if ((lmodel.get车辆零售状态()).equals("审批中")) {
                            lmodel.set车辆零售状态("未卖");
                            lsh库存表Repository.save(lmodel);
                        } else {
                            return "true";
                        }
                    } else {
                        return "true";
                    }
                } else {
                    //同一初始报价单号生命线下，最近一次报价单中（是否驳回=否）的库存编号=null，
                    //则把当前报价单表下的库存编号所对应的销售状态，如此状态=审批中则改为未卖
                    报价单表Model updateModels = repository报价单表.findOne(Integer.parseInt(ids));
                    String kucun = updateModels.get库存编号() + "";
                    if (kucun != null && !"".equals(kucun) && !"null".equals(kucun)) {
                        // 不为kong 那么 就不用 操作
                        return "true";
                    } else {
                        // 为空  那么  就需要 对  1203 的 下属的 库存 进行下一步操作
                        Lsh库存表Model lmodel = lsh库存表Repository.findOne(updateModel.get库存编号());
                        if (lmodel != null) {
                            if ((lmodel.get车辆零售状态()).equals("审批中")) {
                                lmodel.set车辆零售状态("未卖");
                                lsh库存表Repository.save(lmodel);
                            } else {
                                return "true";
                            }
                        } else {
                            return "true";
                        }
                    }
                }
            } else {
                return "true";
            }

            flag = "true";
        } catch (Exception e) {
            logger.error("报价单表的库存修改中出错", e);
            flag = "false";
        }

        return flag;
    }
*/

    /**
     * 撤单后车辆资源释放——New
     *
     * @param qid
     * @param updateModel
     * @return
     */
    private String releaseVechileNew(String qid, 报价单表Model updateModel) {
        if (logger.isDebugEnabled()) {
            logger.debug("qid={}, updateModel={}", qid, JsonObjectUtils.writeAsJson(updateModel));
        }

        String flag = "";
        try {
            if (updateModel.get库存编号() != null) {
                // 逻辑变更，当前报价单下的库存如果为审批中则改为未卖
                Lsh库存表Model lmodel = lsh库存表Repository.findOne(updateModel.get库存编号());
                if (lmodel != null) {
                    if ("审批中".equals(lmodel.get车辆零售状态())) {
                        lmodel.set车辆零售状态("未卖");
                        lsh库存表Repository.save(lmodel);
                    } else {
                        return "true";
                    }
                } else {
                    return "true";
                }
            } else {
                return "true";
            }
            flag = "true";
        } catch (Exception e) {
            logger.error("报价单表的库存修改中出错", e);
            flag = "false";
        }
        return flag;
    }

    private String setMsgToApprovalMan(List<PushApprovalWorkFlowModel> modelList, getCancalApproval re, String permit, String postman) {
        String flag = "";
        //鬼
        if (modelList != null && modelList.size() > 0) {
            PushApprovalWorkFlowModel starmodel = modelList.get(0);
            String commonflag = String.valueOf(starmodel.getType());
            String commonmentStr = "";

            if (commonflag.equals("1")) {
                // 1 就是 订单
                commonmentStr = "订单";
            } else if (commonflag.equals("3")) {
                // 3 就是 合同
                commonmentStr = "合同";
            } else if (commonflag.equals("2")) {
                // 2 意向订单
                commonmentStr = "意向订单";
            }
            // 所有的 接受者 列表 集合
            List<String> recevierList = new ArrayList<>();
            for (int i = 0; i < modelList.size(); i++) {
                // 需要 根据 接收人 对应  的 approvalStatus 判断
                PushApprovalWorkFlowModel inserbasemodel = modelList.get(i);
                recevierList.add(inserbasemodel.getUserName());
            }
            // 去掉 重复的
            List<String> recevicenoDuplist = removeDuplicate(recevierList);
            // 将 消息 存入 和 推送 给 销售经理
            flag = saveLshMsgModel(recevicenoDuplist, commonmentStr, permit, postman, re);

        } else {
            flag = "false";
        }
        return flag;
    }


    private List<String> removeDuplicate(List<String> list) {
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = list.size() - 1; j > i; j--) {
                if (list.get(j).equals(list.get(i))) {
                    list.remove(j);
                }
            }
        }
        return list;
    }

    private String saveLshMsgModel(List<String> recevicenoDuplist, String commonmentStr, String permit, String postman, getCancalApproval re) {
        String flag = "";
        if (recevicenoDuplist != null) {

            报价单表Model baseModel = repository报价单表.findOne(Integer.parseInt(re.qid));
            顾客记录汇总Model selectModels = 顾客记录汇总Repository.findCusByCustomerID(baseModel.get顾客编号());
            String commonClient = selectModels.get顾客姓名();
            String clientTitle = "男".equals(selectModels.get顾客性别())? "先生" : ("女".equals(selectModels.get顾客性别())?"女士":"先生/女士");
            String commonSC = selectModels.get销售顾问();
            String commonTel = selectModels.get电话号码();
            Lsh车型Model caritem = lsh车型Repository.findby车型编号(baseModel.get车型编号());
            String commoncartype = caritem.get车型();
            String commont_content = "消息内容：客户" + commonClient + clientTitle + "，车型为" + commoncartype + "" +
                    " 。电话号码" + commonTel + ",销售顾问" + commonSC + " ，" + commonmentStr + "已经撤单，请知悉";
            try {
                for (int i = 0; i < recevicenoDuplist.size(); i++) {
                    List reciverList = new ArrayList();
                    String recevierUser = recevicenoDuplist.get(i);
                    String mesType = null;
                    String extType = null;
                    if (commonmentStr.equals("合同")) {
                        mesType = "合同";
                        extType = "合同";
                    } else {
                        mesType = "订单";
                        extType = "订单";
                    }
                    LshMsgUtils.getLshMsg(permit, postman, null, recevierUser, mesType, commont_content, postman,
                            commonTel, extType);
                    reciverList.add(recevierUser);
                    JPush.sendPushForAndroidAndIos(commont_content, commont_content, null, reciverList, JPush.Platforms.iTask);
                }
                flag = "true";
            } catch (Exception e) {
                logger.error("发送消息失败", e);
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                flag = "false";
            }


        } else {
            flag = "false";
        }
        return flag;
    }


    /**
     * 保存顾客进店记录
     *
     * @param order
     * @param user
     * @return
     */
    private String saveStroe(报价单表Model order, 顾客记录汇总Model user, String aim ,String customerLevel) {
        //数据异常
        if (null == user) {
            return "1";
        }
        if (null == order) {
            return "2";
        }
        String channel=null;
        if (user!=null&&(user.get顾客渠道().equals("活跃")||user.get顾客渠道().equals("休眠"))){
            channel=user.get顾客渠道();
        }

        String isFirstToStore =  repository顾客进店记录表.isFirstToStore(user.get电话号码(),user.get许可());//是否首次进店
        顾客进店记录表Model new顾客进店记录表 = new 顾客进店记录表Model(
                order.get许可(),
                order.get顾客编号(),
                order.get销售顾问(),
                "否",
                "是",
                "否",
                isFirstToStore,//是否首次进店
                "否",
                null,
                java.sql.Date.valueOf(LocalDate.now()),
                Time.valueOf(LocalTime.of(1, 0, 0)),
                Time.valueOf(LocalTime.of(1, 1, 0)),
                1,
                user.get意向车型A(),//意向车型A
                null,//意向车型B
                null,//意向车型C,
                user.get保有品牌(), //保有品牌,
                customerLevel==null?user.get原顾客级别():customerLevel,// 客户级别,
                user.get顾客首次渠道(),//，顾客来源,
                channel,//顾客再次来源,
                null,//信息渠道,
                "否",//是否评估,
                "否",//是否置换,
                "否",//是否试驾,
                "订单".equals(aim) ? "是" : "否",//是否报价,
                "订单".equals(aim) ? "是" : "否",//是否金融,
                "办手续".equals(aim)||"退订".equals(aim)?"退订":("订单".equals(aim) ? "是" : "否"),
                "否",//是否零售,
                "否",//是否交车,
                null,//对比车型,
                aim,
                order.get报价编号(),//报价编号,
                null,//接待备注,
                "展厅",//接待类型,
                null,//主动集客活动备注,
                null,//调研编号,
                null,//操作人,
                order.get更新账号(),//更新账号,
                DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date())//更新时间
        );
        repository顾客进店记录表.save(new顾客进店记录表);
        return "true";
    }
    private String saveStroe2(报价单表Model order, 顾客记录汇总Model user, String aim ,String customerLevel) {
        //数据异常
        if (null == user) {
            return "1";
        }
        if (null == order) {
            return "2";
        }
        String tmp=null;
        if (user!=null&&(user.get顾客渠道().equals("活跃")||user.get顾客渠道().equals("休眠"))){
            tmp=user.get顾客渠道();
        }

        String isFirstToStore =  repository顾客进店记录表.isFirstToStore(user.get电话号码(),user.get许可());//是否首次进店
        顾客进店记录表Model new顾客进店记录表 = new 顾客进店记录表Model(
                order.get许可(),
                order.get顾客编号(),
                order.get销售顾问(),
                "否",
                "是",
                "否",
                isFirstToStore,//是否首次进店
                "否",
                null,
                java.sql.Date.valueOf(LocalDate.now()),
                Time.valueOf(LocalTime.of(1, 0, 0)),
                Time.valueOf(LocalTime.of(1, 1, 0)),
                1,
                user.get意向车型A(),//意向车型A
                null,//意向车型B
                null,//意向车型C,
                user.get保有品牌(), //保有品牌,
                customerLevel==null?user.get原顾客级别():customerLevel,// 客户级别,
                user.get顾客首次渠道(),//，顾客来源,
                tmp,//顾客再次来源,
                null,//信息渠道,
                "否",//是否评估,
                "否",//是否置换,
                "否",//是否试驾,
                "订单".equals(aim) ? "是" : "否",//是否报价,
                "订单".equals(aim) ? "是" : "否",//是否金融,
                "办手续".equals(aim)||"退订".equals(aim)?"退订":("订单".equals(aim) ? "是" : "否"),
                "否",//是否零售,
                "否",//是否交车,
                null,//对比车型,
                aim,
                order.get报价编号(),//报价编号,
                "意向订单",//接待备注,
                "展厅",//接待类型,
                null,//主动集客活动备注,
                null,//调研编号,
                null,//操作人,
                order.get更新账号(),//更新账号,
                DateFormatUtils.getFormatTimestamp("yyyy-MM-dd HH:mm:ss", new Date())//更新时间
        );
        repository顾客进店记录表.save(new顾客进店记录表);
        return "true";
    }

    /**
     * 根据客户编号和库存编号修改客户订单记录为退订
     *
     * @param order
     */
    private void updateUserOrder(报价单表Model order, String status) {
        //为了严谨性先查询是否存在
        List<顾客订单记录Model> customerOrders = repository顾客订单记录.findOrderByCustIdAndSrockId(order.get顾客编号(), order.get库存编号());
        if (null != customerOrders && customerOrders.size() > 0 ) {
            repository顾客订单记录.unsubscribeOrder(status, order.get顾客编号(), order.get库存编号());
        }
    }

    /**
     * 是否需要资源确认
     *
     * @param list
     * @param 报价单表Model
     * @return
     */
    private boolean checkSource(List<PushApprovalWorkFlowModel> list, 报价单表Model 报价单表Model) {
        boolean re = false;
        re = saleAminCarResourceCheckProcess(list);
        if (re) {
            //发送消息到财务资源确认
            SendMsgRoleUtil.sendMsgByFinance(报价单表Model.get许可(),
                    报价单表Model.get销售顾问(),
                    MessageType.Type.getName(MessageType.MSG_TYPE_CHECK_SOURCE),
                    报价单表Model.get库存编号(),
                    报价单表Model.get顾客编号(),
                    null,
                    DefaultValueConstant.MESSAGE_SET_TYPE_CHECK_SOURCE,
                    DefaultValueConstant.CHECK_CAR_SOURCE_YES,
                    null);
        }
        return re;
    }

    /**
     * 订单修改是否能记录进店日志
     *
     * @param initQid
     * @return
     */
    private boolean isSaveLog(String initQid) {
        boolean re = false;
        if (StringUtils.isNullOrBlank(initQid)) {
            return false;
        }
        //根据初始报价报价编号、还原点和否驳回查询报价单表的报价编号（拉取订单编号）
        List<报价单表Model> models = repository报价单表.findModelByRestore(initQid);
        if (models != null && models.size() > 0) {
            报价单表Model price = models.get(0);

            //根据订单编号查询报价订单表中的订单状态
            报价订单表Model priceOrder = repository报价订单表.findOne(price.get订单编号());
            //当订单状态为意向订单C才能记录日志
            if (null != priceOrder) {
                if ("意向订单C".equals(priceOrder.get订单状态())) {
                    re = true;
                }
            }
        }
        return re;
    }

    @Override
    public ResultData reviewContractApproval(ReviewContractApprovalRequest req, String permit) {
        logger.info("reviewContractApproval传入参数为:" + JsonObjectUtils.writeAsJson(req));
        PageData pd = this.pushApprovalWorkFlowRepository.reviewContractApproval(req, permit);
        if (pd.getTotal() == 0) {
            return new ResultData("true", "暂无记录", pd);
        } else {
            return new ResultData("true", null, pd);
        }
    }

    @Override
    public ResultData reviewContractApprovalDetail(Integer id) {
        logger.info("reviewContractApprovalDetail传入参数为:" + id);
        PushApprovalWorkFlowModel mo = pushApprovalWorkFlowRepository2.findOne(id);
        // id对应条目的流水交易号
        String trueCode = mo.getTranscationCode();
        List list = this.pushApprovalWorkFlowRepository.reviewContractApprovalDetail(id);
        // 将不需要的条目过滤
        List<Map> reList = new ArrayList<>();
        for (Object o : list) {
            Map m = (Map) o;
            String code = (String) ((Map) o).get("transcation_code");
            if (trueCode.equals(code)) {
                reList.add(m);
            }
        }
        return new ResultData("true", null, new PageData(reList, reList.size()));
    }

    /**
     * 财务订金确认（PC手动确认,通过后只是关闭开关，不做任何后处理，task重新提交合同即可）
     */
    @Override
    public ResultData FinanceDepositCheck(FinanceDepositCheckModel modelInput){
        ResultData resultData = new ResultData("false", null, null);
        try{
            FinanceDepositCheckModel model = this.financeDepositCheckRepository.findDepositCheckByQuota(modelInput.getQuotaId());
            if(null != model){
                model.setUpdateTime( new Date());
                model.setCheckStatus(DefaultValueConstant.CHECK_CAR_SOURCE_PASS);
                this.financeDepositCheckRepository.save(model);
                //关闭报价订单中的确认锁
                报价单表Model orderModel = repository报价单表.findBy报价编号(Integer.parseInt(model.getQuotaId()));
                if(null != orderModel){
                    报价订单表Model orderPrice = repository报价订单表.findOrderById(orderModel.get订单编号());
                    orderPrice.setIsDeposit(0);
                    repository报价订单表.save(orderPrice);
                }
            }
            resultData = new ResultData("true", "确认成功",null);
        }catch (Exception e){
            logger.error("财务订金确认异常", e);
        }
        return resultData;
    }


    /**
     * 获取财务订金确认列表
     * @param permit
     * @param re
     * @return
     */
    @Override
    public ResultData FinanceDepositCheckList(String permit,SetService.inOutAccountRequest re) {
        ResultData resultData = new ResultData("false", null, null);
        try {
            if (re != null) {
                PageData pageData = this.pushApprovalWorkFlowRepository.FinanceDepositCheckList(re,permit);
                resultData.setResult("true");
                resultData.setPageData(pageData);
            } else {
                resultData.setMessage("未获取查询参数");
            }
        } catch (Exception e) {
            logger.error("获取财务订金确认列表程序异常", e);
        }
        return resultData;
    }


    /**
     * 检测是否进入财务订金确认审批流程
     * @return
     */
    private boolean checkDepositIsOpen(String permit,String quotedPriceCodeOrVIN,PushApprovalWorkFlowModel pushModel,String initialQuotation){
        boolean result = false;
        //查询基础设置中的设置项
        Itask基础设置Model setTask = itask基础设置Repository.finByPermitAndName(permit, DefaultValueConstant.MESSAGE_HEAD_FINANCE_DEPOSIT_CHECK_CHANGE);
        if(null  == setTask){
            //没有设置过自动设置关闭状态设定 自动补录开启
            itask基础设置Repository.save(new Itask基础设置Model(permit, DefaultValueConstant.MESSAGE_HEAD_FINANCE_DEPOSIT_CHECK_CHANGE,
                    DefaultValueConstant.CHECK_CAR_SOURCE_YES,DateFormatUtils.getFormatTimestamp(DateFormatUtils.TIME_FORMAT_STR_YYYY_MM_DD_HH_MM_SS,new Date())));
        }else if(setTask.get值().equals(DefaultValueConstant.CHECK_CAR_SOURCE_YES)) {
            //检测报价订单表中是否包含订金 包含订金进入流程
            if (hasDeposit(quotedPriceCodeOrVIN)) {
                //根据流水查询报价相关信息
                报价单表Model orderModel = repository报价单表.findOne(Integer.parseInt(quotedPriceCodeOrVIN));
                报价订单表Model modelOrder = repository报价订单表.findOrderById(orderModel.get订单编号());
                BigDecimal deposit = null;
                if (ApprovalUtils.ORDER_CANCEL != pushModel.getType() && ApprovalUtils.INTENTION_ORDER_CANCEL != pushModel.getType()) {
                    deposit = null == modelOrder.get订金加减金额() ? modelOrder.get订金金额() : NumberUtils.add(modelOrder.get订金金额(), modelOrder.get订金加减金额());
                } else {
                    deposit = null == modelOrder.get退订订金金额() ? modelOrder.get订金金额() : NumberUtils.subtract(modelOrder.get订金金额(), modelOrder.get退订订金金额());
                }

                //财务订金信息维护 最终返回是否触发流程
                result = financialDepositSave(orderModel.get初始报价单号(), deposit, orderModel, pushModel, modelOrder);
            }
        }
        return result;
    }

    /**
     * 是否是相同的初始报价单号 false 不卡流程 true 卡
     * @param quotedPriceCodeOrVIN
     * @return
     */
    private boolean isTheSameQuotation(String quotedPriceCodeOrVIN){
        boolean  re = false;
        //合同是每次提交报价单都会新增 所以根据报价单号查询初始报价单号
        报价单表Model model = this.repository报价单表.findBy报价编号(Integer.parseInt(quotedPriceCodeOrVIN));
        //在根据初始报价单号获取所有报价单号集合 是否包含当前传入报价单 如果包含则并且在订金确认表中已经确认 则不卡流程 反之卡
        List<Integer> quotedList =  this.repository报价单表.getQuotationListByInitQuotation(model.get初始报价单号());
        if(quotedList.contains(Integer.parseInt(quotedPriceCodeOrVIN))){
            //拿初始报价单去查询是否存在订金确认的记录
            List<FinanceDepositCheckModel> depositCheckModelList = this.financeDepositCheckRepository.findDepositCheckByInitQuotaAndStatus(model.get初始报价单号(),DefaultValueConstant.CHECK_CAR_SOURCE_PASS);
            //区分初始报价单是否有过订金未确认 如果有并且无订金确认的记录才卡流程
            List<FinanceDepositCheckModel> depositModelList = this.financeDepositCheckRepository.findDepositCheckByInitQuotaAndStatus(model.get初始报价单号(),DefaultValueConstant.CHECK_CAR_SOURCE_HOLD);
            if(depositModelList.size() > 0  && depositCheckModelList.size() == 0 ){
                re = true;
                //修改订金触发流程入口
            }/*else if(depositModelList.size() > 0  && depositCheckModelList.size() != 0){
                re = depositIsUpdate(depositCheckModelList,model);
            }*/
        }
        return re;
    }

    /**
     * 是否是相同的初始报价单号 false 不卡流程 true 卡
     * @param quotedPriceCodeOrVIN
     * @return
     */
    private boolean isTheSameQuotationAdd(String quotedPriceCodeOrVIN){
        boolean  re = false;
        //合同是每次提交报价单都会新增 所以根据报价单号查询初始报价单号
        报价单表Model model = this.repository报价单表.findBy报价编号(Integer.parseInt(quotedPriceCodeOrVIN));
        //在根据初始报价单号获取所有报价单号集合 是否包含当前传入报价单 如果包含则并且在订金确认表中已经确认 则不卡流程 反之卡
        List<Integer> quotedList =  this.repository报价单表.getQuotationListByInitQuotation(model.get初始报价单号());
        if(quotedList.contains(Integer.parseInt(quotedPriceCodeOrVIN))){
            //拿初始报价单去查询是否存在订金确认的记录
            List<FinanceDepositCheckModel> depositCheckModelList = this.financeDepositCheckRepository.findDepositCheckByInitQuotaAndStatus(model.get初始报价单号(),DefaultValueConstant.CHECK_CAR_SOURCE_PASS);
            if(depositCheckModelList.size() == 0 ){
                re = true;
                //修改之后订金再次出发条件
            }/*else if(depositCheckModelList.size() > 0){
              re = depositIsUpdate(depositCheckModelList,model);
            }*/
        }
        return re;
    }

    /**
     * 财务订金确认表维护
     * @param initialQuotation 初始报价单
     * @param deposit 最新订金
     * @param orderModel 报价单信息
     * @param pushModel 流水信息
     * @param orderPriceModel 报价订单信息
     * @return
     */
    private boolean  financialDepositSave(String initialQuotation, BigDecimal deposit, 报价单表Model orderModel,PushApprovalWorkFlowModel pushModel,报价订单表Model orderPriceModel){
        boolean  re = false;
        FinanceDepositCheckModel saveModel = null;
        //检测是否存在当前初始报价单订金确认信息
        FinanceDepositCheckModel financialDepositModel = financeDepositCheckRepository.findDepositCheckByInitQuota(initialQuotation);
        //不存在新增
        if(null == financialDepositModel){
            saveModel =  new FinanceDepositCheckModel(String.valueOf(orderModel.get报价编号()),null,
                    DefaultValueConstant.CHECK_CAR_SOURCE_HOLD,orderModel.get销售顾问(),orderModel.get许可(),pushModel.getType(), new Date(), new Date(),initialQuotation,deposit);
            re = true;
        }else if(depositIsUpdate(financialDepositModel,orderPriceModel,deposit)){
            //存在，且订有变化卡流程并且更新确认表中数据
            saveModel = financialDepositModel;
            saveModel.setUpdateTime(new Date());
            saveModel.setOrderType(pushModel.getType());
            saveModel.setQuotaId(String.valueOf(orderModel.get报价编号()));
            saveModel.setCheckStatus(DefaultValueConstant.CHECK_CAR_SOURCE_HOLD);
            saveModel.setScName(pushModel.getUserName());
            saveModel.setDepositMoney(deposit);
            re = true;
        }else if(!depositIsUpdate(financialDepositModel,orderPriceModel,deposit)){
            //存在，且订无变化不卡流程只更新确认表中数据
            saveModel = financialDepositModel;
            saveModel.setUpdateTime(new Date());
            saveModel.setOrderType(pushModel.getType());
            saveModel.setQuotaId(String.valueOf(orderModel.get报价编号()));
            saveModel.setScName(pushModel.getUserName());
            saveModel.setDepositMoney(deposit);
        }
        this.financeDepositCheckRepository.save(saveModel);
        return re;
    }
    /**
     * 报价是否有订金
     *
     * @param quotedPriceCodeOrVIN
     * @return
     */
    private boolean hasDeposit(String quotedPriceCodeOrVIN) {
        // 根据报价编号查询报价单表获得报价订单编号
        报价单表Model model = this.repository报价单表.findBy报价编号(Integer.parseInt(quotedPriceCodeOrVIN));
        if (null != model) {
            // 根据报价订单编号查询是否有订金
            报价订单表Model orderModel = this.repository报价订单表.findOrderById(model.get订单编号());
            BigDecimal orderAmount = orderModel.get订金金额();
            return orderAmount != null && (orderAmount.doubleValue() > 0);
        } else {
            return false;
        }
    }


    /**
     * 构建财务订金确认记录（mgt审批历史记录）
     */
    private List buildDepositStatus(Set<Integer> typeSet,String quotedPriceCodeOrVIN,String permit,List list){
        if (typeSet.size() == 1 && StringUtils.isNumeric(quotedPriceCodeOrVIN)) {
            FinanceDepositCheckModel model = this.financeDepositCheckRepository.findDepositCheckByQuota(quotedPriceCodeOrVIN);
            if (null != model) {
                Map<String, Object> map = new HashMap<>();
                map.put("id", null);
                map.put("transcation_code", "");
                map.put("step", DefaultValueConstant.MESSAGE_HEAD_FINANCE_DEPOSIT_CHECK_CHANGE);
                map.put("quotedPriceCodeOrVIN", null);
                map.put("flag", null);
                map.put("permit", null);
                map.put("type", ApprovalWorkFlowEnum.ORDER);
                map.put("userName", SendMsgRoleUtil.getFanceName(permit, DefaultValueConstant.MESSAGE_SET_TYPE_FINANCE_DEPOSIT_CHECK, DefaultValueConstant.CHECK_CAR_SOURCE_YES));
                map.put("userNameCN", SendMsgRoleUtil.getFanceUserName(permit, DefaultValueConstant.MESSAGE_SET_TYPE_FINANCE_DEPOSIT_CHECK, DefaultValueConstant.CHECK_CAR_SOURCE_YES));
                map.put("approvalStatus", DefaultValueConstant.CHECK_CAR_SOURCE_PASS.equals(model.getCheckStatus()) ? "已确认" : "待确认");
                map.put("remark", null);
                map.put("processTime", null);
                map.put("transcation_status", null);
                map.put("transcationCode", null);
                list.add(map);
            }
        }
        return list;
    }

    /**
     * 构建车资确认记录（mgt审批历史记录）
     */
    private List buildCarSourceStatus(Set<Integer> typeSet,String quotedPriceCodeOrVIN,String permit,List list){
        if (typeSet.size() == 1 && (typeSet.contains(3) || typeSet.contains(10) || typeSet.contains(12)) && StringUtils.isNumeric(quotedPriceCodeOrVIN)) {
            SaleAdminCarResourceCheckModel model = this.saleAdminCarResourceCheckRepository.getByQuotedPriceCode(Integer.parseInt(quotedPriceCodeOrVIN));
            if (null != model) {
                Map<String, Object> map = new HashMap<>();
                map.put("id", null);
                map.put("transcation_code", "");
                map.put("step", DefaultValueConstant.MESSAGE_HEAD_CHANGE);
                map.put("quotedPriceCodeOrVIN", null);
                map.put("flag", null);
                map.put("permit", null);
                map.put("type", ApprovalWorkFlowEnum.AGREEMENT);
                map.put("userName", SendMsgRoleUtil.getFanceName(permit, DefaultValueConstant.MESSAGE_SET_TYPE_CHECK_SOURCE, DefaultValueConstant.CHECK_CAR_SOURCE_YES));
                map.put("userNameCN", SendMsgRoleUtil.getFanceUserName(permit, DefaultValueConstant.MESSAGE_SET_TYPE_CHECK_SOURCE, DefaultValueConstant.CHECK_CAR_SOURCE_YES));
                map.put("approvalStatus", DefaultValueConstant.CHECK_CAR_SOURCE_PASS.equals(model.getCheckStatus()) ? "已确认" : "待确认");
                map.put("remark", null);
                map.put("processTime", null);
                map.put("transcation_status", null);
                map.put("transcationCode", null);
                list.add(map);
            }
        }
        return list;
    }

    /**
     * 获得车资确认状态
     *
     * @param quotationNum
     * @param permit
     * @return
     */
    private Map<String, String> getCheckSourceStatus(String quotationNum, String permit,Integer type) {
        Map<String, String> map = Maps.newHashMap();
        if (StringUtils.isNullOrBlank(quotationNum)) {
            return map;
        }
        //构建车资确认
        if (StringUtils.isNumeric(quotationNum)) {
            SaleAdminCarResourceCheckModel model = this.saleAdminCarResourceCheckRepository.getByQuotedPriceCode(Integer.parseInt(quotationNum));
            if (null != model) {
                map.put("statusCn", DefaultValueConstant.CHECK_CAR_SOURCE_PASS.equals(model.getCheckStatus()) ? "已确认" : "待确认");
                map.put("statusEn", model.getCheckStatus());
                map.put("typeEn", ApprovalWorkFlowEnum.CHECK_SOURCE + "");
                map.put("typeCn", ApprovalWorkFlowEnum.TYPE.getName(type));
                map.put("role", DefaultValueConstant.SYS_ROLE_SALEADMIN);
                map.put("nameEn", SendMsgRoleUtil.getFanceName(permit, DefaultValueConstant.MESSAGE_SET_TYPE_CHECK_SOURCE, DefaultValueConstant.CHECK_CAR_SOURCE_YES));
                map.put("nameCn", SendMsgRoleUtil.getFanceUserName(permit, DefaultValueConstant.MESSAGE_SET_TYPE_CHECK_SOURCE, DefaultValueConstant.CHECK_CAR_SOURCE_YES));
                map.put("stepCn", ApprovalWorkFlowEnum.TYPE.getName(ApprovalWorkFlowEnum.CHECK_SOURCE));
                map.put("stepEn", ApprovalWorkFlowEnum.TYPE.getName(ApprovalWorkFlowEnum.CHECK_SOURCE));
                map.put("currentStep", DefaultValueConstant.SET_PASS_STR);
            }
        }
        return map;
    }

    /**
     * 获得财务订金确认状态
     *
     * @param quotationNum
     * @param permit
     * @return
     */
    private Map<String, String> getDepositStatus(String quotationNum, String permit) {
        Map<String, String> map = Maps.newHashMap();
        if (StringUtils.isNullOrBlank(quotationNum)) {
            return map;
        }
        //构建财务订金
        if (StringUtils.isNumeric(quotationNum)) {
            FinanceDepositCheckModel model = this.financeDepositCheckRepository.findDepositCheckByQuota(quotationNum);
            if (null != model || isTheSameQuotation(quotationNum)) {
                String checkStatus = null == model?"00":model.getCheckStatus();
                map.put("statusCn", DefaultValueConstant.CHECK_CAR_SOURCE_PASS.equals(checkStatus) ? "已确认" : "待确认");
                map.put("statusEn",checkStatus);
                map.put("typeEn", ApprovalWorkFlowEnum.CHECK_DEPOSIT + "");
                map.put("typeCn", ApprovalWorkFlowEnum.TYPE.getName(ApprovalWorkFlowEnum.CHECK_DEPOSIT));
                map.put("role", DefaultValueConstant.SYS_ROLE_FANCE);
                map.put("nameEn", SendMsgRoleUtil.getFanceName(permit, DefaultValueConstant.MESSAGE_SET_TYPE_FINANCE_DEPOSIT_CHECK, DefaultValueConstant.CHECK_CAR_SOURCE_YES));
                map.put("nameCn", SendMsgRoleUtil.getFanceUserName(permit, DefaultValueConstant.MESSAGE_SET_TYPE_FINANCE_DEPOSIT_CHECK, DefaultValueConstant.CHECK_CAR_SOURCE_YES));
                map.put("stepCn", ApprovalWorkFlowEnum.TYPE.getName(ApprovalWorkFlowEnum.CHECK_DEPOSIT));
                map.put("stepEn", ApprovalWorkFlowEnum.TYPE.getName(ApprovalWorkFlowEnum.CHECK_DEPOSIT));
                map.put("currentStep", DefaultValueConstant.SET_PASS_STR);
            }
        }
        return map;
    }

    /**
     * 订单状态、车型改变，相关更新
     * @param quotationOrderModel 当前记录的报价单
     * @param type 类型 （意向订单修改：7、订单修改：6、合同修改：10、换票：12、退票再开票：99）
     */
    @Override
    @Transactional
    public void updateOldOrNewRecord(报价单表Model quotationOrderModel,int type) {
        // 上次报价单 （因为上面已经把这次的设置为还原点了，所以取倒数第二个还原点的数据即是上一次的记录）
        报价单表Model lastQuotationOrderModel = repository报价单表.getLastSecondQuotationOrder(quotationOrderModel.get初始报价单号());
        if (lastQuotationOrderModel == null || StringUtils.isNullOrBlank(lastQuotationOrderModel.get车型编号())) {
            return;   // 没有上次还原点记录，直接返回
        }

        Timestamp time = new Timestamp(new Date().getTime());
        // 上次的车型
        Lsh车型Model lastCarModel = lsh车型Repository.findby车型编号(lastQuotationOrderModel.get车型编号());
        // 本次的车型
        Lsh车型Model thisCarModel = lsh车型Repository.findby车型编号(quotationOrderModel.get车型编号());
        // 上次报价订单
        报价订单表Model lastOrderModel = repository报价订单表.findOne(lastQuotationOrderModel.get订单编号());
        // 本次报价订单
        报价订单表Model thisOrderModel = repository报价订单表.findOne(quotationOrderModel.get订单编号());
        // 上次报价交车
        报价交车表Model lastGiveCarModel = null;
        boolean lastGiveCarFlag = false;
        if (!StringUtils.isNullOrBlank(lastQuotationOrderModel.get交车())) {
            lastGiveCarModel = repository报价交车表.findOne(lastQuotationOrderModel.get交车());
            lastGiveCarFlag = true;
        }
        // 这次报价交车
        报价交车表Model thisGiveCarModel = null;
        if (!StringUtils.isNullOrBlank(quotationOrderModel.get交车())) {
            thisGiveCarModel = repository报价交车表.findOne(quotationOrderModel.get交车());
        }

        // 车型是否改变判断使用  (来源+品牌+车系+车型+车款)
        String lastCarTypeStr = new StringBuffer().append(lastCarModel.get来源()).append(lastCarModel.get品牌()).append(lastCarModel.get级别()).
                append(StringUtils.isNullOrBlank(lastCarModel.get车型())?"":lastCarModel.get车型()).append(StringUtils.isNullOrBlank(lastCarModel.get车型详细())?"":lastCarModel.get车型详细()).toString();
        String thisCarTypeStr = new StringBuffer().append(thisCarModel.get来源()).append(thisCarModel.get品牌()).append(thisCarModel.get级别()).
                append(StringUtils.isNullOrBlank(thisCarModel.get车型())?"":thisCarModel.get车型()).append(StringUtils.isNullOrBlank(thisCarModel.get车型详细())?"":thisCarModel.get车型详细()).toString();

        // 判断是否为第一次修改订单 （之前是否有修改订单的审批记录）
        List<PushApprovalWorkFlowModel> modifyList =  pushApprovalWorkFlowRepository.getBeforeModifyOrderApprovalRecord(quotationOrderModel.get报价编号(),quotationOrderModel.get初始报价单号());
        BigDecimal thisDepositMoney = thisOrderModel.get订金金额();  // 本次订金金额
        BigDecimal thisDepositDiffMoney = StringUtils.isNullOrBlank(thisOrderModel.get订金加减金额()) ? new BigDecimal("0") : thisOrderModel.get订金加减金额(); // 本次订金加减金额
        BigDecimal lastDepositMoney = lastOrderModel.get订金金额(); // 上次订金金额
        BigDecimal lastDepositDiffMoney = StringUtils.isNullOrBlank(lastOrderModel.get订金加减金额()) ? new BigDecimal("0") : lastOrderModel.get订金加减金额(); // 上次订金加减金额

        switch (type) {
            // 意向订单修改为意向订单
            case ApprovalWorkFlowEnum.ORDER_INTENTION_UPDATE :
            {

                // 车型不变 , 更新当前记录
                if (lastCarTypeStr.equals(thisCarTypeStr)) {
                    thisOrderModel.set订单修改日期(new java.sql.Date(time.getTime()));

                    // 不是第一次修改订单、车型不变，则设置 1:订金金额 = 上一个还原点的订金金额 + 上一个还原点的订金加减金额 ，
                    // 2:订金加减金额 = （当前的订金金额 + 当前的订金加减金额） - （上一个还原点订金金额 + 上一个还原点订金加减金额）
                    if (null != modifyList && !modifyList.isEmpty()) {
                        thisOrderModel.set订金金额(lastDepositMoney.add(lastDepositDiffMoney));
                        thisOrderModel.set订金加减金额(thisDepositMoney.add(thisDepositDiffMoney).subtract(lastDepositMoney.add(lastDepositDiffMoney)));
                    } else { // 第一次修改，车型不变，什么都不用做

                    }

                    // 不管第几次修改订金加减日期都设置
                    thisOrderModel.set订金加减日期(new java.sql.Date(time.getTime()));
                    thisOrderModel.set更新时间(time);
                    repository报价订单表.save(thisOrderModel);

                } else { // 车型改变 ， 更新上条记录和当前记录
                    // 上一条报价单 做车型改变的标示
                    lastQuotationOrderModel.setCarTypeChange(1); // 车型改变标示
                    repository报价单表.save(lastQuotationOrderModel);

                    lastOrderModel.set订单失销日期(new java.sql.Date(time.getTime()));
                    lastOrderModel.set退订订金金额(lastDepositMoney.add(lastDepositDiffMoney));
                    lastOrderModel.set更新时间(time);
                    repository报价订单表.save(lastOrderModel);

                    // 车型改变，不管是第几次修改订单，都设置 1：订金金额 = 当前订金金额 + 当前订金加减金额 ，2：订金加减金额 = null
                    thisOrderModel.set订金金额(thisDepositMoney.add(thisDepositDiffMoney));
                    thisOrderModel.set订金加减金额(null);

                    thisOrderModel.set订单审批通过日期(time);
                    thisOrderModel.set订单签署日期(new java.sql.Date(time.getTime()));
                    thisOrderModel.set更新时间(time);
                    repository报价订单表.save(thisOrderModel);
                }
            }
            break;

            // 订单修改 (1：意向订单修改为订单、2：订单修改为订单（包括正常流程订单修改为订单和退票后又发生修改订单两种情况）)
            case ApprovalWorkFlowEnum.ORDER_UPDATE :
            {
                // 意向订单修改为订单
                if ("意向金".equals(lastOrderModel.get订金类型())) {
                    // 车型不变
                    if (lastCarTypeStr.equals(thisCarTypeStr)) {
                        thisOrderModel.set订单签署日期(new java.sql.Date(time.getTime()));

                        // 不是第一次修改订单、车型不变，则设置 1:订金金额 = 上一个还原点的订金金额 + 上一个还原点的订金加减金额 ，
                        // 2:订金加减金额 = （当前的订金金额 + 当前的订金加减金额） - （上一个还原点订金金额 + 上一个还原点订金加减金额）
                        if (null != modifyList && !modifyList.isEmpty()) {
                            thisOrderModel.set订金金额(lastDepositMoney.add(lastDepositDiffMoney));
                            thisOrderModel.set订金加减金额(thisDepositMoney.add(thisDepositDiffMoney).subtract(lastDepositMoney.add(lastDepositDiffMoney)));
                        } else { // 第一次修改，车型不变，什么都不用做

                        }

                        thisOrderModel.set订金加减日期(new java.sql.Date(time.getTime()));
                        thisOrderModel.set更新时间(time);
                        repository报价订单表.save(thisOrderModel);
                    } else { // 车型改变
                        // 上一条报价单 做车型改变的标示
                        lastQuotationOrderModel.setCarTypeChange(1); // 车型改变标示
                        repository报价单表.save(lastQuotationOrderModel);

                        lastOrderModel.set订单失销日期(new java.sql.Date(time.getTime()));
                        lastOrderModel.set退订订金金额(lastDepositMoney.add(lastDepositDiffMoney));
                        lastOrderModel.set更新时间(time);
                        repository报价订单表.save(lastOrderModel);

                        // 车型改变，不管是第几次修改订单，都设置 1：订金金额 = 当前订金金额 + 当前订金加减金额 ，2：订金加减金额 = null
                        thisOrderModel.set订金金额(thisDepositMoney.add(thisDepositDiffMoney));
                        thisOrderModel.set订金加减金额(null);

                        thisOrderModel.set订单审批通过日期(time);
                        thisOrderModel.set订单签署日期(new java.sql.Date(time.getTime()));
                        thisOrderModel.set更新时间(time);
                        repository报价订单表.save(thisOrderModel);
                    }

                } else {  // 订单修改为订单
                    // 车型不变
                    if (lastCarTypeStr.equals(thisCarTypeStr)) {
                        thisOrderModel.set订单修改日期(new java.sql.Date(time.getTime()));

                        // 不是第一次修改订单、车型不变，则设置 1:订金金额 = 上一个还原点的订金金额 + 上一个还原点的订金加减金额 ，
                        // 2:订金加减金额 = （当前的订金金额 + 当前的订金加减金额） - （上一个还原点订金金额 + 上一个还原点订金加减金额）
                        if (null != modifyList && !modifyList.isEmpty()) {
                            thisOrderModel.set订金金额(lastDepositMoney.add(lastDepositDiffMoney));
                            thisOrderModel.set订金加减金额(thisDepositMoney.add(thisDepositDiffMoney).subtract(lastDepositMoney.add(lastDepositDiffMoney)));
                        } else { // 第一次修改，车型不变，什么都不用做

                        }

                        thisOrderModel.set订金加减日期(new java.sql.Date(time.getTime()));
                        thisOrderModel.set更新时间(time);
                        repository报价订单表.save(thisOrderModel);
                    } else { // 车型改变
                        // 上一条报价单 做车型改变的标示
                        lastQuotationOrderModel.setCarTypeChange(1); // 车型改变标示
                        repository报价单表.save(lastQuotationOrderModel);

                        lastOrderModel.set订单失销日期(new java.sql.Date(time.getTime()));
                        lastOrderModel.set退订订金金额(lastDepositMoney.add(lastDepositDiffMoney));
                        lastOrderModel.set更新时间(time);
                        repository报价订单表.save(lastOrderModel);

                        // 车型改变，不管是第几次修改订单，都设置 1：订金金额 = 当前订金金额 + 当前订金加减金额 ，2：订金加减金额 = null
                        thisOrderModel.set订金金额(thisDepositMoney.add(thisDepositDiffMoney));
                        thisOrderModel.set订金加减金额(null);

                        thisOrderModel.set订单审批通过日期(time);
                        thisOrderModel.set订单签署日期(new java.sql.Date(time.getTime()));
                        thisOrderModel.set更新时间(time);
                        repository报价订单表.save(thisOrderModel);
                    }
                }
            }
            break;

            // 合同 （退票后走到合同的情况）
            case ApprovalWorkFlowEnum.AGREEMENT :
            {
                // 如果是发生过退票(退票->...合同)，走以下流程
                List<PushApprovalWorkFlowModel> approvaRefundlList = pushApprovalWorkFlowRepository.getRefundRecordByInitQuotationNum(quotationOrderModel.get初始报价单号());
                if (null != approvaRefundlList && !approvaRefundlList.isEmpty()) {
                    // 退票之后，直到合同审批通过的期间，车型都没有发生过改变，则退订上一条单子（设置失销日期等） （这里包括下面的流程1和2,流程3会在订单修改期间退订上一个单子）
                    // (ps:退票之后的流程：1退票->合同(车型不变) 2退票->订单修改（车型没有改变）->合同 3退票->订单修改（车型发生改变）->合同)

                    // 取出从退票开始到合同期间所有的报价单，判断这期间车型是否发生过改变
                    PushApprovalWorkFlowModel lastRefundApproval = approvaRefundlList.get(0); // 最近的一次退票
                    Integer lastRundQuotationNum = Integer.valueOf(lastRefundApproval.getQuotedPriceCodeOrVin()); // 上次退票的报价编号
                    Integer thisQuotationNum = quotationOrderModel.get报价编号();  // 这次的报价编号
                    List<Lsh车型Model> carTypes = pushApprovalWorkFlowRepository.getCarTypeByQuotationNums(lastRundQuotationNum,thisQuotationNum);
                    String carTypeStr = "";
                    boolean flag = false; // 车型是否改变标示
                    if (null != carTypes && !carTypes.isEmpty()) {
                        carTypeStr = new StringBuffer().append(carTypes.get(0).get来源()).append(carTypes.get(0).get品牌()).append(carTypes.get(0).get级别()).
                                append(StringUtils.isNullOrBlank(carTypes.get(0).get车型())?"":carTypes.get(0).get车型()).append(StringUtils.isNullOrBlank(carTypes.get(0).get车型详细())?"":carTypes.get(0).get车型详细()).toString();
                        for (int i=1; i<carTypes.size(); i++) {
                            String tempStr = new StringBuffer().append(carTypes.get(i).get来源()).append(carTypes.get(i).get品牌()).append(carTypes.get(i).get级别()).
                                    append(StringUtils.isNullOrBlank(carTypes.get(i).get车型())?"":carTypes.get(i).get车型()).append(StringUtils.isNullOrBlank(carTypes.get(i).get车型详细())?"":carTypes.get(i).get车型详细()).toString();
                            if (!carTypeStr.equals(tempStr)) {
                                flag  = true;
                                break;
                            } else {
                                carTypeStr = tempStr;
                            }
                        }
                    }
                    // 车型没有改变,则退订上一个单子
                    if (!flag) {
                        lastQuotationOrderModel.setCarTypeChange(1); // 车型改变标示
                        repository报价单表.save(lastQuotationOrderModel);
                        lastOrderModel.set订单失销日期(new java.sql.Date(lastOrderModel.get订单审批通过日期().getTime()));  //原订单日期
                        lastOrderModel.set退订订金金额(lastDepositMoney.add(lastDepositDiffMoney));
                        lastOrderModel.set更新时间(time);
                        repository报价订单表.save(lastOrderModel);
                        if(lastGiveCarFlag) {
                            lastGiveCarModel.set更新时间(time);
                            repository报价交车表.save(lastGiveCarModel);
                        }

                        thisOrderModel.set订单审批通过日期(lastOrderModel.get订单审批通过日期());  // 原订单日期
                        thisOrderModel.set订单签署日期(new java.sql.Date(lastOrderModel.get订单审批通过日期().getTime())); // 原订单日期
                        lastOrderModel.set退订订金金额(lastDepositMoney.add(lastDepositDiffMoney)); // 原订单金额
                        thisOrderModel.set更新时间(time);
                        // 判断退票到合同期间，若经过了订单修改，则设置订单修改日期为最后一次订单修改审批通过的日期
                        List<PushApprovalWorkFlowModel> approvalModels =  pushApprovalWorkFlowRepository.getApprovalRecordByCondition(quotationOrderModel.get初始报价单号(),ApprovalWorkFlowEnum.ORDER_UPDATE,lastRundQuotationNum,thisQuotationNum);
                        if (null != approvalModels && !approvalModels.isEmpty()) {
                            thisOrderModel.set订单修改日期(new java.sql.Date(approvalModels.get(0).getProcessTime().getTime()));
                        }
                        repository报价订单表.save(thisOrderModel);
                        thisGiveCarModel.set合同签约日期(new java.sql.Date(time.getTime()));
                        thisGiveCarModel.set更新时间(time);
                        repository报价交车表.save(thisGiveCarModel);
                    }
                }
            }
            break;

            // 合同修改
            case ApprovalWorkFlowEnum.AGREEMENT_UPDATE :
            {
                // 车型不变
                if (lastCarTypeStr.equals(thisCarTypeStr)) {
                    thisGiveCarModel.set合同修改日期(new java.sql.Date(time.getTime()));
                    thisGiveCarModel.set更新时间(time);
                    repository报价交车表.save(thisGiveCarModel);
                } else { // 车型改变
                    // 上一条报价单 做车型改变的标示
                    lastQuotationOrderModel.setCarTypeChange(1); // 车型改变标示
                    repository报价单表.save(lastQuotationOrderModel);

                    lastOrderModel.set订单失销日期(new java.sql.Date(time.getTime()));
                    lastOrderModel.set退订订金金额(lastDepositMoney.add(lastDepositDiffMoney));
                    lastOrderModel.set更新时间(time);
                    repository报价订单表.save(lastOrderModel);
                    if(lastGiveCarFlag) {
                        lastGiveCarModel.set合同失销日期(new java.sql.Date(time.getTime()));
                        lastGiveCarModel.set更新时间(time);
                        repository报价交车表.save(lastGiveCarModel);
                    }

                    thisOrderModel.set订单审批通过日期(time);
                    thisOrderModel.set订单签署日期(new java.sql.Date(time.getTime()));
                    thisOrderModel.set订金金额(new BigDecimal(thisGiveCarModel.get销售价格()));  // 同现订现交
                    thisOrderModel.set更新时间(time);
                    repository报价订单表.save(thisOrderModel);
                    thisGiveCarModel.set合同签约日期(new java.sql.Date(time.getTime()));
                    thisGiveCarModel.set更新时间(time);
                    repository报价交车表.save(thisGiveCarModel);
                }
            }

            break;

            // 退票
            case ApprovalWorkFlowEnum.TICKET_RETREAT :
            {
                if(lastGiveCarFlag) {
                    lastGiveCarModel.set合同失销日期(new java.sql.Date(time.getTime()));  // 设置上次记录的合同失销日期为退票通过日期
                    repository报价交车表.save(lastGiveCarModel);
                }
            }
            break;
            // 换票
            case ApprovalWorkFlowEnum.TICKET_CHANG :
            {
                // 车型不变
                if (lastCarTypeStr.equals(thisCarTypeStr)) {
                    // 上一条报价单 做车型改变的标示
                    lastQuotationOrderModel.setCarTypeChange(1); // 车型改变标示
                    repository报价单表.save(lastQuotationOrderModel);

                    lastOrderModel.set订单失销日期(new java.sql.Date(time.getTime()));
                    lastOrderModel.set更新时间(time);
                    repository报价订单表.save(lastOrderModel);
                    if(lastGiveCarFlag) {
                        lastGiveCarModel.set合同失销日期(new java.sql.Date(time.getTime()));
                        lastGiveCarModel.set退票时间(time);
                        lastGiveCarModel.set更新时间(time);
                        repository报价交车表.save(lastGiveCarModel);
                    }

                    thisOrderModel.set订单审批通过日期(lastOrderModel.get订单审批通过日期());
                    thisOrderModel.set订单签署日期(new java.sql.Date(lastOrderModel.get订单审批通过日期().getTime()));  // 未换票前的订单审批通过日期
                    thisOrderModel.set更新时间(time);
                    repository报价订单表.save(thisOrderModel);
                    thisGiveCarModel.set合同签约日期(new java.sql.Date(time.getTime()));
                    thisGiveCarModel.set开票时间(time);
                    repository报价交车表.save(thisGiveCarModel);
                } else { // 车型改变
                    // 上一条报价单 做车型改变的标示
                    lastQuotationOrderModel.setCarTypeChange(1); // 车型改变标示
                    repository报价单表.save(lastQuotationOrderModel);

                    lastOrderModel.set订单失销日期(new java.sql.Date(time.getTime()));
                    lastOrderModel.set更新时间(time);
                    repository报价订单表.save(lastOrderModel);
                    if(lastGiveCarFlag) {
                        lastGiveCarModel.set合同失销日期(new java.sql.Date(time.getTime()));
                        lastGiveCarModel.set退票时间(time);
                        lastGiveCarModel.set更新时间(time);
                        repository报价交车表.save(lastGiveCarModel);
                    }

                    thisOrderModel.set订单审批通过日期(time);
                    thisOrderModel.set订单签署日期(new java.sql.Date(time.getTime()));
                    thisOrderModel.set更新时间(time);
                    repository报价订单表.save(thisOrderModel);
                    thisGiveCarModel.set合同签约日期(new java.sql.Date(time.getTime()));
                    thisGiveCarModel.set开票时间(time);      // 设置为换票审批通过日期
                    repository报价交车表.save(thisGiveCarModel);
                }
            }
            break;

            // 退票再开票 (只需设置当前单子：订单日期、合同签署日期、开票日期)
            case 99 :
            {
                // 若是退票再开票的情况
                List<PushApprovalWorkFlowModel> approvaRefundlList = pushApprovalWorkFlowRepository.getRefundRecordByInitQuotationNum(quotationOrderModel.get初始报价单号());
                if (null != approvaRefundlList && !approvaRefundlList.isEmpty()) {
                    thisOrderModel.set订单审批通过日期(time);
                    thisOrderModel.set订单签署日期(new java.sql.Date(time.getTime()));
                    thisOrderModel.set更新时间(time);
                    repository报价订单表.save(thisOrderModel);

                    thisGiveCarModel.set合同签约日期(new java.sql.Date(time.getTime()));
                    thisGiveCarModel.set开票时间(time);
                    repository报价交车表.save(thisGiveCarModel);
                }
            }
            break;
        }
    }

    /**
     * 判定当前订金是否有过更改
     * @return
     */
    private boolean depositIsUpdate( FinanceDepositCheckModel depositCheckModelList, 报价订单表Model orderModel,BigDecimal deposit){
        boolean re =  false;
        //查询当前报价订金与上次确认定金是否一致不一致触发流程
        if(depositCheckModelList.getDepositMoney().compareTo(deposit)!= 0){
            re = true;
        }
        return re;
    }

    /**
     * 第三方精品调用维护
     * @param pushType
     * @param quoteOrderModel
     */
    private void thirdBoutiqueCallMaintain(Integer pushType,报价单表Model quoteOrderModel) {
        报价交车表Model giveCarModel = repository报价交车表.findby编号(quoteOrderModel.get交车());
        String contractNum = giveCarModel.get合同号();
        if(StringUtils.isNullOrBlank(contractNum)) {
            logger.error("审批后处理，第三方精品调用维护：该订单合同编号为空。报价编号为：{}",quoteOrderModel.get报价编号());
            return;
        }
        // 查找精品维护记录
        TBoutiqueCallCheckModel boutique = tBoutiqueCallCheckRepository.findBycontroactNUm(contractNum);
        // 没有三方精品，返回
        if (boutique == null) {
            logger.info("审批后处理，第三方精品维护：该订单没有第三方精品信息。报价编号为：{}",quoteOrderModel.get报价编号());
            return;
        }
        boutique.setQuotaId(quoteOrderModel.get报价编号().toString());
        boutique.setCheckStatus(DefaultValueConstant.CHECK_CAR_SOURCE_HOLD); // 设置为待确认
        boutique.setScName(quoteOrderModel.get销售顾问());
        boutique.setOrderType(pushType);
        boutique.setUpdateTime(DateUtils.getCurrentTimestamp());
        tBoutiqueCallCheckRepository.save(boutique);
    }

}

